ovirtsdk4.services
View Source
# -*- coding: utf-8 -*- # # Copyright (c) 2016 Red Hat, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from ovirtsdk4 import Error from ovirtsdk4 import types from ovirtsdk4.service import Service from ovirtsdk4.writer import Writer class AffinityGroupService(Service): """ This service manages a single affinity group. """ def __init__(self, connection, path): super(AffinityGroupService, self).__init__(connection, path) self._host_labels_service = None self._hosts_service = None self._vm_labels_service = None self._vms_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieve the affinity group details. [source,xml] ---- <affinity_group id="00000000-0000-0000-0000-000000000000"> <name>AF_GROUP_001</name> <cluster id="00000000-0000-0000-0000-000000000000"/> <positive>true</positive> <enforcing>true</enforcing> </affinity_group> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the affinity group. [source] ---- DELETE /ovirt-engine/api/clusters/000-000/affinitygroups/123-456 ---- This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, group, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the affinity group. This method supports the following parameters: `group`:: The affinity group. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('group', group, types.AffinityGroup), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(group, headers, query, wait) def host_labels_service(self): """ Returns a reference to the service that manages the list of all host labels attached to this affinity group. """ return AffinityGroupHostLabelsService(self._connection, '%s/hostlabels' % self._path) def hosts_service(self): """ Returns a reference to the service that manages the list of all hosts attached to this affinity group. """ return AffinityGroupHostsService(self._connection, '%s/hosts' % self._path) def vm_labels_service(self): """ Returns a reference to the service that manages the list of all virtual machine labels attached to this affinity group. """ return AffinityGroupVmLabelsService(self._connection, '%s/vmlabels' % self._path) def vms_service(self): """ Returns a reference to the service that manages the list of all virtual machines attached to this affinity group. """ return AffinityGroupVmsService(self._connection, '%s/vms' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'hostlabels': return self.host_labels_service() if path.startswith('hostlabels/'): return self.host_labels_service().service(path[11:]) if path == 'hosts': return self.hosts_service() if path.startswith('hosts/'): return self.hosts_service().service(path[6:]) if path == 'vmlabels': return self.vm_labels_service() if path.startswith('vmlabels/'): return self.vm_labels_service().service(path[9:]) if path == 'vms': return self.vms_service() if path.startswith('vms/'): return self.vms_service().service(path[4:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityGroupService:%s' % self._path class AffinityGroupHostService(Service): """ This service manages a single host to affinity group assignment. """ def __init__(self, connection, path): super(AffinityGroupHostService, self).__init__(connection, path) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove host from the affinity group. This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityGroupHostService:%s' % self._path class AffinityGroupHostLabelService(Service): """ This service manages a single host label assigned to an affinity group. """ def __init__(self, connection, path): super(AffinityGroupHostLabelService, self).__init__(connection, path) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove this label from the affinity group. This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityGroupHostLabelService:%s' % self._path class AffinityGroupHostLabelsService(Service): """ This service manages a collection of all host labels assigned to an affinity group. """ def __init__(self, connection, path): super(AffinityGroupHostLabelsService, self).__init__(connection, path) self._label_service = None def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Adds a host label to the affinity group. For example, to add the label `789` to the affinity group `456` of cluster `123`, send a request like this: .... POST /ovirt-engine/api/clusters/123/affinitygroups/456/hostlabels .... With the following body: [source,xml] ---- <affinity_label id="789"/> ---- This method supports the following parameters: `label`:: The AffinityLabel object to add to the affinity group. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all host labels assigned to this affinity group. The order of the returned labels isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of host labels to return. If not specified, all the labels are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def label_service(self, id): """ Access the service that manages the host label assignment to this affinity group. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupHostLabelService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityGroupHostLabelsService:%s' % self._path class AffinityGroupHostsService(Service): """ This service manages a collection of all hosts assigned to an affinity group. """ def __init__(self, connection, path): super(AffinityGroupHostsService, self).__init__(connection, path) self._host_service = None def add( self, host, headers=None, query=None, wait=True, **kwargs ): """ Adds a host to the affinity group. For example, to add the host `789` to the affinity group `456` of cluster `123`, send a request like this: .... POST /ovirt-engine/api/clusters/123/affinitygroups/456/hosts .... With the following body: [source,xml] ---- <host id="789"/> ---- This method supports the following parameters: `host`:: The host to be added to the affinity group. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(host, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all hosts assigned to this affinity group. The order of the returned hosts isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of hosts to return. If not specified, all the hosts are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def host_service(self, id): """ Access the service that manages the host assignment to this affinity group. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupHostService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityGroupHostsService:%s' % self._path class AffinityGroupVmService(Service): """ This service manages a single virtual machine to affinity group assignment. """ def __init__(self, connection, path): super(AffinityGroupVmService, self).__init__(connection, path) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove this virtual machine from the affinity group. This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityGroupVmService:%s' % self._path class AffinityGroupVmLabelService(Service): """ This service manages a single virtual machine label assigned to an affinity group. """ def __init__(self, connection, path): super(AffinityGroupVmLabelService, self).__init__(connection, path) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove this label from the affinity group. This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityGroupVmLabelService:%s' % self._path class AffinityGroupVmLabelsService(Service): """ This service manages a collection of all virtual machine labels assigned to an affinity group. """ def __init__(self, connection, path): super(AffinityGroupVmLabelsService, self).__init__(connection, path) self._label_service = None def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Adds a virtual machine label to the affinity group. For example, to add the label `789` to the affinity group `456` of cluster `123`, send a request like this: .... POST /ovirt-engine/api/clusters/123/affinitygroups/456/vmlabels .... With the following body: [source,xml] ---- <affinity_label id="789"/> ---- This method supports the following parameters: `label`:: The AffinityLabel object to add to the affinity group. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all virtual machine labels assigned to this affinity group. The order of the returned labels isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of virtual machine labels to return. If not specified, all the labels are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def label_service(self, id): """ Access the service that manages the virtual machine label assignment to this affinity group. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupVmLabelService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityGroupVmLabelsService:%s' % self._path class AffinityGroupVmsService(Service): """ This service manages a collection of all the virtual machines assigned to an affinity group. """ def __init__(self, connection, path): super(AffinityGroupVmsService, self).__init__(connection, path) self._vm_service = None def add( self, vm, headers=None, query=None, wait=True, **kwargs ): """ Adds a virtual machine to the affinity group. For example, to add the virtual machine `789` to the affinity group `456` of cluster `123`, send a request like this: .... POST /ovirt-engine/api/clusters/123/affinitygroups/456/vms .... With the following body: [source,xml] ---- <vm id="789"/> ---- """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all virtual machines assigned to this affinity group. The order of the returned virtual machines isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of virtual machines to return. If not specified, all the virtual machines are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def vm_service(self, id): """ Access the service that manages the virtual machine assignment to this affinity group. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupVmService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.vm_service(path) return self.vm_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityGroupVmsService:%s' % self._path class AffinityGroupsService(Service): """ The affinity groups service manages virtual machine relationships and dependencies. """ def __init__(self, connection, path): super(AffinityGroupsService, self).__init__(connection, path) self._group_service = None def add( self, group, headers=None, query=None, wait=True, **kwargs ): """ Create a new affinity group. Post a request like in the example below to create a new affinity group: [source] ---- POST /ovirt-engine/api/clusters/000-000/affinitygroups ---- And use the following example in its body: [source,xml] ---- <affinity_group> <name>AF_GROUP_001</name> <hosts_rule> <enforcing>true</enforcing> <positive>true</positive> </hosts_rule> <vms_rule> <enabled>false</enabled> </vms_rule> </affinity_group> ---- This method supports the following parameters: `group`:: The affinity group object to create. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('group', group, types.AffinityGroup), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(group, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List existing affinity groups. The order of the affinity groups results isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of affinity groups to return. If not specified all the affinity groups are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def group_service(self, id): """ Access the affinity group service that manages the affinity group specified by an ID. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.group_service(path) return self.group_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityGroupsService:%s' % self._path class AffinityLabelService(Service): """ The details of a single affinity label. """ def __init__(self, connection, path): super(AffinityLabelService, self).__init__(connection, path) self._hosts_service = None self._vms_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the details of a label. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes a label from the system and clears all assignments of the removed label. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, label, headers=None, query=None, wait=True, **kwargs ): """ Updates a label. This call will update all metadata, such as the name or description. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(label, headers, query, wait) def hosts_service(self): """ List all hosts with this label. """ return AffinityLabelHostsService(self._connection, '%s/hosts' % self._path) def vms_service(self): """ List all virtual machines with this label. """ return AffinityLabelVmsService(self._connection, '%s/vms' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'hosts': return self.hosts_service() if path.startswith('hosts/'): return self.hosts_service().service(path[6:]) if path == 'vms': return self.vms_service() if path.startswith('vms/'): return self.vms_service().service(path[4:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityLabelService:%s' % self._path class AffinityLabelHostService(Service): """ This service represents a host that has a specific label when accessed through the affinitylabels/hosts subcollection. """ def __init__(self, connection, path): super(AffinityLabelHostService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves details about a host that has this label assigned. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Remove a label from a host. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityLabelHostService:%s' % self._path class AffinityLabelHostsService(Service): """ This service represents list of hosts that have a specific label when accessed through the affinitylabels/hosts subcollection. """ def __init__(self, connection, path): super(AffinityLabelHostsService, self).__init__(connection, path) self._host_service = None def add( self, host, headers=None, query=None, wait=True, **kwargs ): """ Add a label to a host. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(host, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List all hosts with the label. The order of the returned hosts isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def host_service(self, id): """ A link to the specific label-host assignment to allow label removal. """ Service._check_types([ ('id', id, str), ]) return AffinityLabelHostService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityLabelHostsService:%s' % self._path class AffinityLabelVmService(Service): """ This service represents a vm that has a specific label when accessed through the affinitylabels/vms subcollection. """ def __init__(self, connection, path): super(AffinityLabelVmService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves details about a vm that has this label assigned. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Remove a label from a vm. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityLabelVmService:%s' % self._path class AffinityLabelVmsService(Service): """ This service represents list of vms that have a specific label when accessed through the affinitylabels/vms subcollection. """ def __init__(self, connection, path): super(AffinityLabelVmsService, self).__init__(connection, path) self._vm_service = None def add( self, vm, headers=None, query=None, wait=True, **kwargs ): """ Add a label to a vm. """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List all virtual machines with the label. The order of the returned virtual machines isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def vm_service(self, id): """ A link to the specific label-vm assignment to allow label removal. """ Service._check_types([ ('id', id, str), ]) return AffinityLabelVmService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.vm_service(path) return self.vm_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityLabelVmsService:%s' % self._path class AffinityLabelsService(Service): """ Manages the affinity labels available in the system. """ def __init__(self, connection, path): super(AffinityLabelsService, self).__init__(connection, path) self._label_service = None def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Creates a new label. The label is automatically attached to all entities mentioned in the vms or hosts lists. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all labels present in the system. The order of the returned labels isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of labels to return. If not specified all the labels are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def label_service(self, id): """ Link to a single label details. """ Service._check_types([ ('id', id, str), ]) return AffinityLabelService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityLabelsService:%s' % self._path class AreaService(Service): """ This annotation is intended to specify what oVirt area is the annotated concept related to. Currently the following areas are in use, and they are closely related to the oVirt teams, but not necessarily the same: - Infrastructure - Network - SLA - Storage - Virtualization A concept may be associated to more than one area, or to no area. The value of this annotation is intended for reporting only, and it doesn't affect at all the generated code or the validity of the model """ def __init__(self, connection, path): super(AreaService, self).__init__(connection, path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AreaService:%s' % self._path class AssignedAffinityLabelService(Service): """ This service represents one label to entity assignment when accessed using the entities/affinitylabels subcollection. """ def __init__(self, connection, path): super(AssignedAffinityLabelService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves details about the attached label. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes the label from an entity. Does not touch the label itself. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AssignedAffinityLabelService:%s' % self._path class AssignedAffinityLabelsService(Service): """ This service is used to list and manipulate affinity labels that are assigned to supported entities when accessed using entities/affinitylabels. """ def __init__(self, connection, path): super(AssignedAffinityLabelsService, self).__init__(connection, path) self._label_service = None def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Attaches a label to an entity. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all labels that are attached to an entity. The order of the returned entities isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def label_service(self, id): """ Link to the specific entity-label assignment to allow removal. """ Service._check_types([ ('id', id, str), ]) return AssignedAffinityLabelService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AssignedAffinityLabelsService:%s' % self._path class AssignedCpuProfileService(Service): """ """ def __init__(self, connection, path): super(AssignedCpuProfileService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AssignedCpuProfileService:%s' % self._path class AssignedCpuProfilesService(Service): """ """ def __init__(self, connection, path): super(AssignedCpuProfilesService, self).__init__(connection, path) self._profile_service = None def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new cpu profile for the cluster. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.CpuProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the CPU profiles assigned to the cluster. The order of the returned CPU profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return AssignedCpuProfileService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AssignedCpuProfilesService:%s' % self._path class AssignedDiskProfileService(Service): """ """ def __init__(self, connection, path): super(AssignedDiskProfileService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AssignedDiskProfileService:%s' % self._path class AssignedDiskProfilesService(Service): """ """ def __init__(self, connection, path): super(AssignedDiskProfilesService, self).__init__(connection, path) self._profile_service = None def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new disk profile for the storage domain. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.DiskProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disk profiles assigned to the storage domain. The order of the returned disk profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return AssignedDiskProfileService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AssignedDiskProfilesService:%s' % self._path class AssignedPermissionsService(Service): """ Represents a permission sub-collection, scoped by user, group or some entity type. """ def __init__(self, connection, path): super(AssignedPermissionsService, self).__init__(connection, path) self._permission_service = None def add( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Assign a new permission to a user or group for specific entity. For example, to assign the `UserVmManager` role to the virtual machine with id `123` to the user with id `456` send a request like this: .... POST /ovirt-engine/api/vms/123/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>UserVmManager</name> </role> <user id="456"/> </permission> ---- To assign the `SuperUser` role to the system to the user with id `456` send a request like this: .... POST /ovirt-engine/api/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>SuperUser</name> </role> <user id="456"/> </permission> ---- If you want to assign permission to the group instead of the user please replace the `user` element with the `group` element with proper `id` of the group. For example to assign the `UserRole` role to the cluster with id `123` to the group with id `789` send a request like this: .... POST /ovirt-engine/api/clusters/123/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>UserRole</name> </role> <group id="789"/> </permission> ---- This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_cluster_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the cluster to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_data_center_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the data center to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_group_level( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new group level permission for a given virtual machine. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_host_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the host to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List all the permissions of the specific entity. For example to list all the permissions of the cluster with id `123` send a request like this: .... GET /ovirt-engine/api/clusters/123/permissions .... [source,xml] ---- <permissions> <permission id="456"> <cluster id="123"/> <role id="789"/> <user id="451"/> </permission> <permission id="654"> <cluster id="123"/> <role id="789"/> <group id="127"/> </permission> </permissions> ---- The order of the returned permissions isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def add_storage_domain_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the storage domain to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_template_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the template to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_user_level( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new user level permission for a given virtual machine. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_vm_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the vm to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_vm_pool_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the vm pool to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def permission_service(self, id): """ Sub-resource locator method, returns individual permission resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return PermissionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.permission_service(path) return self.permission_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AssignedPermissionsService:%s' % self._path class AssignedRolesService(Service): """ Represents a roles sub-collection, for example scoped by user. """ def __init__(self, connection, path): super(AssignedRolesService, self).__init__(connection, path) self._role_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the roles assigned to the permission. The order of the returned roles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of roles to return. If not specified all the roles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def role_service(self, id): """ Sub-resource locator method, returns individual role resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return RoleService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.role_service(path) return self.role_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AssignedRolesService:%s' % self._path class AssignedTagService(Service): """ A service to manage assignment of specific tag to specific entities in system. """ def __init__(self, connection, path): super(AssignedTagService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the information about the assigned tag. For example to retrieve the information about the tag with the id `456` which is assigned to virtual machine with id `123` send a request like this: .... GET /ovirt-engine/api/vms/123/tags/456 .... [source,xml] ---- <tag href="/ovirt-engine/api/tags/456" id="456"> <name>root</name> <description>root</description> <vm href="/ovirt-engine/api/vms/123" id="123"/> </tag> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Unassign tag from specific entity in the system. For example to unassign the tag with id `456` from virtual machine with id `123` send a request like this: .... DELETE /ovirt-engine/api/vms/123/tags/456 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AssignedTagService:%s' % self._path class AssignedTagsService(Service): """ A service to manage collection of assignment of tags to specific entities in system. """ def __init__(self, connection, path): super(AssignedTagsService, self).__init__(connection, path) self._tag_service = None def add( self, tag, headers=None, query=None, wait=True, **kwargs ): """ Assign tag to specific entity in the system. For example to assign tag `mytag` to virtual machine with the id `123` send a request like this: .... POST /ovirt-engine/api/vms/123/tags .... With a request body like this: [source,xml] ---- <tag> <name>mytag</name> </tag> ---- This method supports the following parameters: `tag`:: The assigned tag. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('tag', tag, types.Tag), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(tag, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all tags assigned to the specific entity. For example to list all the tags of the virtual machine with id `123` send a request like this: .... GET /ovirt-engine/api/vms/123/tags .... [source,xml] ---- <tags> <tag href="/ovirt-engine/api/tags/222" id="222"> <name>mytag</name> <description>mytag</description> <vm href="/ovirt-engine/api/vms/123" id="123"/> </tag> </tags> ---- The order of the returned tags isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of tags to return. If not specified all the tags are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def tag_service(self, id): """ Reference to the service that manages assignment of specific tag. """ Service._check_types([ ('id', id, str), ]) return AssignedTagService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.tag_service(path) return self.tag_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AssignedTagsService:%s' % self._path class AssignedVnicProfileService(Service): """ """ def __init__(self, connection, path): super(AssignedVnicProfileService, self).__init__(connection, path) self._permissions_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AssignedVnicProfileService:%s' % self._path class AssignedVnicProfilesService(Service): """ """ def __init__(self, connection, path): super(AssignedVnicProfilesService, self).__init__(connection, path) self._profile_service = None def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new virtual network interface card profile for the network. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.VnicProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of VNIC profiles assifned to the network. The order of the returned VNIC profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return AssignedVnicProfileService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AssignedVnicProfilesService:%s' % self._path class AttachedStorageDomainService(Service): """ """ def __init__(self, connection, path): super(AttachedStorageDomainService, self).__init__(connection, path) self._disks_service = None def activate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation activates an attached storage domain. Once the storage domain is activated it is ready for use with the data center. [source] ---- POST /ovirt-engine/api/datacenters/123/storagedomains/456/activate ---- The activate action does not take any action specific parameters, so the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait) def deactivate( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ This operation deactivates an attached storage domain. Once the storage domain is deactivated it will not be used with the data center. For example, to deactivate storage domain `456`, send the following request: [source] ---- POST /ovirt-engine/api/datacenters/123/storagedomains/456/deactivate ---- With a request body like this: [source,xml] ---- <action/> ---- If the `force` parameter is `true` then the operation will succeed, even if the OVF update which takes place before the deactivation of the storage domain failed. If the `force` parameter is `false` and the OVF update failed, the deactivation of the storage domain will also fail. This method supports the following parameters: `async_`:: Indicates if the deactivation should be performed asynchronously. `force`:: Indicates if the operation should succeed and the storage domain should be moved to a deactivated state, even if the OVF update for the storage domain failed. For example, to deactivate storage domain `456` using force flag, send the following request: [source] ---- POST /ovirt-engine/api/datacenters/123/storagedomains/456/deactivate ---- With a request body like this: [source,xml] ---- <action> <force>true</force> <action> ---- This parameter is optional, and the default value is `false`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'deactivate', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def disks_service(self): """ """ return AttachedStorageDomainDisksService(self._connection, '%s/disks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AttachedStorageDomainService:%s' % self._path class AttachedStorageDomainDisksService(Service): """ Manages the collection of disks available inside an storage domain that is attached to a data center. """ def __init__(self, connection, path): super(AttachedStorageDomainDisksService, self).__init__(connection, path) self._disk_service = None def add( self, disk, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Adds or registers a disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To add a new disk use the <<services/disks/methods/add, add>> operation of the service that manages the disks of the system. To register an unregistered disk use the <<services/attached_storage_domain_disk/methods/register, register>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: The disk to add or register. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieve the list of disks that are available in the storage domain. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ Reference to the service that manages a specific disk. """ Service._check_types([ ('id', id, str), ]) return AttachedStorageDomainDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AttachedStorageDomainDisksService:%s' % self._path class AttachedStorageDomainsService(Service): """ Manages the storage domains attached to a data center. """ def __init__(self, connection, path): super(AttachedStorageDomainsService, self).__init__(connection, path) self._storage_domain_service = None def add( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Attaches an existing storage domain to the data center. This method supports the following parameters: `storage_domain`:: The storage domain to attach to the data center. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of storage domains attached to the data center. The order of the returned storage domains isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of storage domains to return. If not specified all the storage domains are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def storage_domain_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return AttachedStorageDomainService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_domain_service(path) return self.storage_domain_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AttachedStorageDomainsService:%s' % self._path class BalanceService(Service): """ """ def __init__(self, connection, path): super(BalanceService, self).__init__(connection, path) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'BalanceService:%s' % self._path class BalancesService(Service): """ """ def __init__(self, connection, path): super(BalancesService, self).__init__(connection, path) self._balance_service = None def add( self, balance, headers=None, query=None, wait=True, **kwargs ): """ Add a balance module to a specified user defined scheduling policy. """ # Check the types of the parameters: Service._check_types([ ('balance', balance, types.Balance), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(balance, headers, query, wait) def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of balance modules used by the scheduling policy. The order of the returned balance modules isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of balances to return. If not specified all the balances are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def balance_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return BalanceService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.balance_service(path) return self.balance_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'BalancesService:%s' % self._path class BookmarkService(Service): """ A service to manage a bookmark. """ def __init__(self, connection, path): super(BookmarkService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get a bookmark. An example for getting a bookmark: [source] ---- GET /ovirt-engine/api/bookmarks/123 ---- [source,xml] ---- <bookmark href="/ovirt-engine/api/bookmarks/123" id="123"> <name>example_vm</name> <value>vm: name=example*</value> </bookmark> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove a bookmark. An example for removing a bookmark: [source] ---- DELETE /ovirt-engine/api/bookmarks/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, bookmark, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update a bookmark. An example for updating a bookmark: [source] ---- PUT /ovirt-engine/api/bookmarks/123 ---- With the request body: [source,xml] ---- <bookmark> <name>new_example_vm</name> <value>vm: name=new_example*</value> </bookmark> ---- This method supports the following parameters: `bookmark`:: The updated bookmark. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bookmark', bookmark, types.Bookmark), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(bookmark, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'BookmarkService:%s' % self._path class BookmarksService(Service): """ A service to manage bookmarks. """ def __init__(self, connection, path): super(BookmarksService, self).__init__(connection, path) self._bookmark_service = None def add( self, bookmark, headers=None, query=None, wait=True, **kwargs ): """ Adding a new bookmark. Example of adding a bookmark: [source] ---- POST /ovirt-engine/api/bookmarks ---- [source,xml] ---- <bookmark> <name>new_example_vm</name> <value>vm: name=new_example*</value> </bookmark> ---- This method supports the following parameters: `bookmark`:: The added bookmark. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bookmark', bookmark, types.Bookmark), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(bookmark, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Listing all the available bookmarks. Example of listing bookmarks: [source] ---- GET /ovirt-engine/api/bookmarks ---- [source,xml] ---- <bookmarks> <bookmark href="/ovirt-engine/api/bookmarks/123" id="123"> <name>database</name> <value>vm: name=database*</value> </bookmark> <bookmark href="/ovirt-engine/api/bookmarks/456" id="456"> <name>example</name> <value>vm: name=example*</value> </bookmark> </bookmarks> ---- The order of the returned bookmarks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of bookmarks to return. If not specified all the bookmarks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def bookmark_service(self, id): """ A reference to the service managing a specific bookmark. """ Service._check_types([ ('id', id, str), ]) return BookmarkService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.bookmark_service(path) return self.bookmark_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'BookmarksService:%s' % self._path class ClusterService(Service): """ A service to manage a specific cluster. """ def __init__(self, connection, path): super(ClusterService, self).__init__(connection, path) self._affinity_groups_service = None self._cpu_profiles_service = None self._enabled_features_service = None self._external_network_providers_service = None self._gluster_hooks_service = None self._gluster_volumes_service = None self._network_filters_service = None self._networks_service = None self._permissions_service = None def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets information about the cluster. An example of getting a cluster: [source] ---- GET /ovirt-engine/api/clusters/123 ---- [source,xml] ---- <cluster href="/ovirt-engine/api/clusters/123" id="123"> <actions> <link href="/ovirt-engine/api/clusters/123/resetemulatedmachine" rel="resetemulatedmachine"/> </actions> <name>Default</name> <description>The default server cluster</description> <link href="/ovirt-engine/api/clusters/123/networks" rel="networks"/> <link href="/ovirt-engine/api/clusters/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/clusters/123/glustervolumes" rel="glustervolumes"/> <link href="/ovirt-engine/api/clusters/123/glusterhooks" rel="glusterhooks"/> <link href="/ovirt-engine/api/clusters/123/affinitygroups" rel="affinitygroups"/> <link href="/ovirt-engine/api/clusters/123/cpuprofiles" rel="cpuprofiles"/> <ballooning_enabled>false</ballooning_enabled> <cpu> <architecture>x86_64</architecture> <type>Intel Nehalem Family</type> </cpu> <error_handling> <on_error>migrate</on_error> </error_handling> <fencing_policy> <enabled>true</enabled> <skip_if_connectivity_broken> <enabled>false</enabled> <threshold>50</threshold> </skip_if_connectivity_broken> <skip_if_sd_active> <enabled>false</enabled> </skip_if_sd_active> </fencing_policy> <gluster_service>false</gluster_service> <ha_reservation>false</ha_reservation> <ksm> <enabled>true</enabled> <merge_across_nodes>true</merge_across_nodes> </ksm> <memory_policy> <over_commit> <percent>100</percent> </over_commit> <transparent_hugepages> <enabled>true</enabled> </transparent_hugepages> </memory_policy> <migration> <auto_converge>inherit</auto_converge> <bandwidth> <assignment_method>auto</assignment_method> </bandwidth> <compressed>inherit</compressed> </migration> <required_rng_sources> <required_rng_source>random</required_rng_source> </required_rng_sources> <scheduling_policy href="/ovirt-engine/api/schedulingpolicies/456" id="456"/> <threads_as_cores>false</threads_as_cores> <trusted_service>false</trusted_service> <tunnel_migration>false</tunnel_migration> <version> <major>4</major> <minor>0</minor> </version> <virt_service>true</virt_service> <data_center href="/ovirt-engine/api/datacenters/111" id="111"/> </cluster> ---- This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def refresh_gluster_heal_status( self, headers=None, query=None, wait=True, **kwargs ): """ Refresh the Gluster heal info for all volumes in cluster. For example, Cluster `123`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/123/refreshglusterhealstatus ---- """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'refreshglusterhealstatus', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the cluster from the system. [source] ---- DELETE /ovirt-engine/api/clusters/00000000-0000-0000-0000-000000000000 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def reset_emulated_machine( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the reset should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'resetemulatedmachine', None, headers, query, wait) def sync_all_networks( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Synchronizes all networks on the cluster. [source] ---- POST /ovirt-engine/api/clusters/123/syncallnetworks ---- With a request body like this: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'syncallnetworks', None, headers, query, wait) def update( self, cluster, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates information about the cluster. Only the specified fields are updated; others remain unchanged. For example, to update the cluster's CPU: [source] ---- PUT /ovirt-engine/api/clusters/123 ---- With a request body like this: [source,xml] ---- <cluster> <cpu> <type>Intel Haswell-noTSX Family</type> </cpu> </cluster> ---- """ # Check the types of the parameters: Service._check_types([ ('cluster', cluster, types.Cluster), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(cluster, headers, query, wait) def upgrade( self, async_=None, upgrade_action=None, headers=None, query=None, wait=True, **kwargs ): """ Start or finish upgrade process for the cluster based on the action value. This action marks the cluster for upgrade or clears the upgrade running flag on the cluster based on the action value which takes values of start or stop. [source] ---- POST /ovirt-engine/api/clusters/123/upgrade ---- With a request body like this to mark the cluster for upgrade: [source,xml] ---- <action> <upgrade_action> start </upgrade_action> </action> ---- This method supports the following parameters: `upgrade_action`:: The action to be performed. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('upgrade_action', upgrade_action, types.ClusterUpgradeAction), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, upgrade_action=upgrade_action, ) # Send the request and wait for the response: return self._internal_action(action, 'upgrade', None, headers, query, wait) def affinity_groups_service(self): """ A reference to the service that manages affinity groups. """ return AffinityGroupsService(self._connection, '%s/affinitygroups' % self._path) def cpu_profiles_service(self): """ A reference to the service that manages assigned CPU profiles for the cluster. """ return AssignedCpuProfilesService(self._connection, '%s/cpuprofiles' % self._path) def enabled_features_service(self): """ A reference to the service that manages the collection of enabled features for the cluster. """ return ClusterEnabledFeaturesService(self._connection, '%s/enabledfeatures' % self._path) def external_network_providers_service(self): """ A reference to the service that manages the collection of external network providers. """ return ClusterExternalProvidersService(self._connection, '%s/externalnetworkproviders' % self._path) def gluster_hooks_service(self): """ A reference to the service that manages the Gluster hooks for the cluster. """ return GlusterHooksService(self._connection, '%s/glusterhooks' % self._path) def gluster_volumes_service(self): """ A reference to the service that manages Gluster volumes for the cluster. """ return GlusterVolumesService(self._connection, '%s/glustervolumes' % self._path) def network_filters_service(self): """ A sub-collection with all the supported network filters for the cluster. """ return NetworkFiltersService(self._connection, '%s/networkfilters' % self._path) def networks_service(self): """ A reference to the service that manages assigned networks for the cluster. """ return ClusterNetworksService(self._connection, '%s/networks' % self._path) def permissions_service(self): """ A reference to permissions. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'affinitygroups': return self.affinity_groups_service() if path.startswith('affinitygroups/'): return self.affinity_groups_service().service(path[15:]) if path == 'cpuprofiles': return self.cpu_profiles_service() if path.startswith('cpuprofiles/'): return self.cpu_profiles_service().service(path[12:]) if path == 'enabledfeatures': return self.enabled_features_service() if path.startswith('enabledfeatures/'): return self.enabled_features_service().service(path[16:]) if path == 'externalnetworkproviders': return self.external_network_providers_service() if path.startswith('externalnetworkproviders/'): return self.external_network_providers_service().service(path[25:]) if path == 'glusterhooks': return self.gluster_hooks_service() if path.startswith('glusterhooks/'): return self.gluster_hooks_service().service(path[13:]) if path == 'glustervolumes': return self.gluster_volumes_service() if path.startswith('glustervolumes/'): return self.gluster_volumes_service().service(path[15:]) if path == 'networkfilters': return self.network_filters_service() if path.startswith('networkfilters/'): return self.network_filters_service().service(path[15:]) if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ClusterService:%s' % self._path class ClusterEnabledFeatureService(Service): """ Represents a feature enabled for the cluster. """ def __init__(self, connection, path): super(ClusterEnabledFeatureService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Provides the information about the cluster feature enabled. For example, to find details of the enabled feature `456` for cluster `123`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/123/enabledfeatures/456 ---- That will return a <<types/cluster_feature, ClusterFeature>> object containing the name: [source,xml] ---- <cluster_feature id="456"> <name>libgfapi_supported</name> </cluster_feature> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Disables a cluster feature. For example, to disable the feature `456` of cluster `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/clusters/123/enabledfeatures/456 ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ClusterEnabledFeatureService:%s' % self._path class ClusterEnabledFeaturesService(Service): """ Provides information about the additional features that are enabled for this cluster. The features that are enabled are the available features for the cluster level """ def __init__(self, connection, path): super(ClusterEnabledFeaturesService, self).__init__(connection, path) self._feature_service = None def add( self, feature, headers=None, query=None, wait=True, **kwargs ): """ Enable an additional feature for a cluster. For example, to enable a feature `456` on cluster `123`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/123/enabledfeatures ---- The request body should look like this: [source,xml] ---- <cluster_feature id="456"/> ---- """ # Check the types of the parameters: Service._check_types([ ('feature', feature, types.ClusterFeature), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(feature, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the additional features enabled for the cluster. For example, to get the features enabled for cluster `123` send a request like this: [source] ---- GET /ovirt-engine/api/clusters/123/enabledfeatures ---- This will return a list of features: [source,xml] ---- <enabled_features> <cluster_feature id="123"> <name>test_feature</name> </cluster_feature> ... </enabled_features> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def feature_service(self, id): """ A reference to the service that provides information about a specific feature enabled for the cluster. """ Service._check_types([ ('id', id, str), ]) return ClusterEnabledFeatureService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.feature_service(path) return self.feature_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ClusterEnabledFeaturesService:%s' % self._path class ClusterExternalProvidersService(Service): """ This service lists external providers. """ def __init__(self, connection, path): super(ClusterExternalProvidersService, self).__init__(connection, path) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of external providers. The order of the returned list of providers is not guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ClusterExternalProvidersService:%s' % self._path class ClusterFeatureService(Service): """ Represents a feature enabled for the cluster level """ def __init__(self, connection, path): super(ClusterFeatureService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Provides the information about the a cluster feature supported by a cluster level. For example, to find details of the cluster feature `456` for cluster level 4.1, send a request like this: [source] ---- GET /ovirt-engine/api/clusterlevels/4.1/clusterfeatures/456 ---- That will return a <<types/cluster_feature, ClusterFeature>> object containing the name: [source,xml] ---- <cluster_feature id="456"> <name>libgfapi_supported</name> </cluster_feature> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ClusterFeatureService:%s' % self._path class ClusterFeaturesService(Service): """ Provides information about the cluster features that are supported by a cluster level. """ def __init__(self, connection, path): super(ClusterFeaturesService, self).__init__(connection, path) self._feature_service = None def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the cluster features supported by the cluster level. [source] ---- GET /ovirt-engine/api/clusterlevels/4.1/clusterfeatures ---- This will return a list of cluster features supported by the cluster level: [source,xml] ---- <cluster_features> <cluster_feature id="123"> <name>test_feature</name> </cluster_feature> ... </cluster_features> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def feature_service(self, id): """ Reference to the service that provides information about a specific feature. """ Service._check_types([ ('id', id, str), ]) return ClusterFeatureService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.feature_service(path) return self.feature_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ClusterFeaturesService:%s' % self._path class ClusterLevelService(Service): """ Provides information about a specific cluster level. See the <<services/cluster_levels,ClusterLevels>> service for more information. """ def __init__(self, connection, path): super(ClusterLevelService, self).__init__(connection, path) self._cluster_features_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Provides the information about the capabilities of the specific cluster level managed by this service. For example, to find what CPU types are supported by level 3.6 you can send a request like this: [source] ---- GET /ovirt-engine/api/clusterlevels/3.6 ---- That will return a <<types/cluster_level, ClusterLevel>> object containing the supported CPU types, and other information which describes the cluster level: [source,xml] ---- <cluster_level id="3.6"> <cpu_types> <cpu_type> <name>Intel Nehalem Family</name> <level>3</level> <architecture>x86_64</architecture> </cpu_type> ... </cpu_types> <permits> <permit id="1"> <name>create_vm</name> <administrative>false</administrative> </permit> ... </permits> </cluster_level> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def cluster_features_service(self): """ Reference to the service that manages the collection of supported features for this cluster level. """ return ClusterFeaturesService(self._connection, '%s/clusterfeatures' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'clusterfeatures': return self.cluster_features_service() if path.startswith('clusterfeatures/'): return self.cluster_features_service().service(path[16:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ClusterLevelService:%s' % self._path class ClusterLevelsService(Service): """ Provides information about the capabilities of different cluster levels supported by the engine. Version 4.0 of the engine supports levels 4.0 and 3.6. Each of these levels support different sets of CPU types, for example. This service provides that information. """ def __init__(self, connection, path): super(ClusterLevelsService, self).__init__(connection, path) self._level_service = None def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the cluster levels supported by the system. [source] ---- GET /ovirt-engine/api/clusterlevels ---- This will return a list of available cluster levels. [source,xml] ---- <cluster_levels> <cluster_level id="4.0"> ... </cluster_level> ... </cluster_levels> ---- The order of the returned cluster levels isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def level_service(self, id): """ Reference to the service that provides information about an specific cluster level. """ Service._check_types([ ('id', id, str), ]) return ClusterLevelService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.level_service(path) return self.level_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ClusterLevelsService:%s' % self._path class ClusterNetworkService(Service): """ A service to manage a specific cluster network. """ def __init__(self, connection, path): super(ClusterNetworkService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the cluster network details. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Unassigns the network from a cluster. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, network, headers=None, query=None, wait=True, **kwargs ): """ Updates the network in the cluster. This method supports the following parameters: `network`:: The cluster network. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(network, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ClusterNetworkService:%s' % self._path class ClusterNetworksService(Service): """ A service to manage cluster networks. """ def __init__(self, connection, path): super(ClusterNetworksService, self).__init__(connection, path) self._network_service = None def add( self, network, headers=None, query=None, wait=True, **kwargs ): """ Assigns the network to a cluster. Post a request like in the example below to assign the network to a cluster: [source] ---- POST /ovirt-engine/api/clusters/123/networks ---- Use the following example in its body: [source,xml] ---- <network id="123" /> ---- This method supports the following parameters: `network`:: The network object to be assigned to the cluster. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(network, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the networks that are assigned to the cluster. The order of the returned clusters isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified, all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def network_service(self, id): """ Access the cluster network service that manages the cluster network specified by an ID. """ Service._check_types([ ('id', id, str), ]) return ClusterNetworkService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ClusterNetworksService:%s' % self._path class ClustersService(Service): """ A service to manage clusters. """ def __init__(self, connection, path): super(ClustersService, self).__init__(connection, path) self._cluster_service = None def add( self, cluster, headers=None, query=None, wait=True, **kwargs ): """ Creates a new cluster. This requires the `name`, `cpu.type`, and `data_center` attributes. Identify the data center with either the `id` or `name` attribute. [source] ---- POST /ovirt-engine/api/clusters ---- With a request body like this: [source,xml] ---- <cluster> <name>mycluster</name> <cpu> <type>Intel Nehalem Family</type> </cpu> <data_center id="123"/> </cluster> ---- To create a cluster with an external network provider to be deployed on every host that is added to the cluster, send a request like this: [source] ---- POST /ovirt-engine/api/clusters ---- With a request body containing a reference to the desired provider: [source,xml] ---- <cluster> <name>mycluster</name> <cpu> <type>Intel Nehalem Family</type> </cpu> <data_center id="123"/> <external_network_providers> <external_provider name="ovirt-provider-ovn"/> </external_network_providers> </cluster> ---- """ # Check the types of the parameters: Service._check_types([ ('cluster', cluster, types.Cluster), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(cluster, headers, query, wait) def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of clusters of the system. The order of the returned clusters is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of clusters to return. If not specified, all the clusters are returned. `search`:: A query string used to restrict the returned clusters. `case_sensitive`:: Indicates if the search should be performed taking case into account. The default value is `true`, which means that case is taken into account. To search ignoring case, set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def cluster_service(self, id): """ A reference to the service that manages a specific cluster. """ Service._check_types([ ('id', id, str), ]) return ClusterService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.cluster_service(path) return self.cluster_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ClustersService:%s' % self._path class CopyableService(Service): """ """ def __init__(self, connection, path): super(CopyableService, self).__init__(connection, path) def copy( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the copy should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'CopyableService:%s' % self._path class CpuProfileService(Service): """ """ def __init__(self, connection, path): super(CpuProfileService, self).__init__(connection, path) self._permissions_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, profile, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified cpu profile in the system. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.CpuProfile), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(profile, headers, query, wait) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'CpuProfileService:%s' % self._path class CpuProfilesService(Service): """ """ def __init__(self, connection, path): super(CpuProfilesService, self).__init__(connection, path) self._profile_service = None def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new cpu profile to the system. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.CpuProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of CPU profiles of the system. The order of the returned list of CPU profiles is random. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified, all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return CpuProfileService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'CpuProfilesService:%s' % self._path class DataCenterService(Service): """ A service to manage a data center. """ def __init__(self, connection, path): super(DataCenterService, self).__init__(connection, path) self._clusters_service = None self._iscsi_bonds_service = None self._networks_service = None self._permissions_service = None self._qoss_service = None self._quotas_service = None self._storage_domains_service = None def clean_finished_tasks( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Currently, the storage pool manager (SPM) fails to switch to another host if the SPM has uncleared tasks. Clearing all finished tasks enables the SPM switching. For example, to clean all the finished tasks on a data center with ID `123` send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/cleanfinishedtasks ---- With a request body like this: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'cleanfinishedtasks', None, headers, query, wait) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get a data center. An example of getting a data center: [source] ---- GET /ovirt-engine/api/datacenters/123 ---- [source,xml] ---- <data_center href="/ovirt-engine/api/datacenters/123" id="123"> <name>Default</name> <description>The default Data Center</description> <link href="/ovirt-engine/api/datacenters/123/clusters" rel="clusters"/> <link href="/ovirt-engine/api/datacenters/123/storagedomains" rel="storagedomains"/> <link href="/ovirt-engine/api/datacenters/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/datacenters/123/networks" rel="networks"/> <link href="/ovirt-engine/api/datacenters/123/quotas" rel="quotas"/> <link href="/ovirt-engine/api/datacenters/123/qoss" rel="qoss"/> <link href="/ovirt-engine/api/datacenters/123/iscsibonds" rel="iscsibonds"/> <local>false</local> <quota_mode>disabled</quota_mode> <status>up</status> <storage_format>v3</storage_format> <supported_versions> <version> <major>4</major> <minor>0</minor> </version> </supported_versions> <version> <major>4</major> <minor>0</minor> </version> <mac_pool href="/ovirt-engine/api/macpools/456" id="456"/> </data_center> ---- This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, force=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the data center. [source] ---- DELETE /ovirt-engine/api/datacenters/123 ---- Without any special parameters, the storage domains attached to the data center are detached and then removed from the storage. If something fails when performing this operation, for example if there is no host available to remove the storage domains from the storage, the complete operation will fail. If the `force` parameter is `true` then the operation will always succeed, even if something fails while removing one storage domain, for example. The failure is just ignored and the data center is removed from the database anyway. This method supports the following parameters: `force`:: Indicates if the operation should succeed, and the storage domain removed from the database, even if something fails during the operation. This parameter is optional, and the default value is `false`. `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('force', force, bool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if force is not None: force = Writer.render_boolean(force) query['force'] = force if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def set_master( self, async_=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Used for manually setting a storage domain in the data center as a master. For example, for setting a storage domain with ID '456' as a master on a data center with ID '123', send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/setmaster ---- With a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> </action> ---- The new master storage domain can be also specified by its name. This method supports the following parameters: `storage_domain`:: The new master storage domain for the data center. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'setmaster', None, headers, query, wait) def update( self, data_center, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the data center. The `name`, `description`, `storage_type`, `version`, `storage_format` and `mac_pool` elements are updatable post-creation. For example, to change the name and description of data center `123` send a request like this: [source] ---- PUT /ovirt-engine/api/datacenters/123 ---- With a request body like this: [source,xml] ---- <data_center> <name>myupdatedname</name> <description>An updated description for the data center</description> </data_center> ---- This method supports the following parameters: `data_center`:: The data center that is being updated. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('data_center', data_center, types.DataCenter), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(data_center, headers, query, wait) def clusters_service(self): """ """ return ClustersService(self._connection, '%s/clusters' % self._path) def iscsi_bonds_service(self): """ Reference to the iSCSI bonds service. """ return IscsiBondsService(self._connection, '%s/iscsibonds' % self._path) def networks_service(self): """ Returns a reference to the service, that manages the networks, that are associated with the data center. """ return DataCenterNetworksService(self._connection, '%s/networks' % self._path) def permissions_service(self): """ Reference to the permissions service. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def qoss_service(self): """ Reference to the QOSs service. """ return QossService(self._connection, '%s/qoss' % self._path) def quotas_service(self): """ Reference to the quotas service. """ return QuotasService(self._connection, '%s/quotas' % self._path) def storage_domains_service(self): """ Attach and detach storage domains to and from a data center. For attaching a single storage domain we should use the following POST request: [source] ---- POST /ovirt-engine/api/datacenters/123/storagedomains ---- With a request body like this: [source,xml] ---- <storage_domain> <name>data1</name> </storage_domain> ---- For detaching a single storage domain we should use the following DELETE request: [source] ---- DELETE /ovirt-engine/api/datacenters/123/storagedomains/123 ---- """ return AttachedStorageDomainsService(self._connection, '%s/storagedomains' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'clusters': return self.clusters_service() if path.startswith('clusters/'): return self.clusters_service().service(path[9:]) if path == 'iscsibonds': return self.iscsi_bonds_service() if path.startswith('iscsibonds/'): return self.iscsi_bonds_service().service(path[11:]) if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'qoss': return self.qoss_service() if path.startswith('qoss/'): return self.qoss_service().service(path[5:]) if path == 'quotas': return self.quotas_service() if path.startswith('quotas/'): return self.quotas_service().service(path[7:]) if path == 'storagedomains': return self.storage_domains_service() if path.startswith('storagedomains/'): return self.storage_domains_service().service(path[15:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DataCenterService:%s' % self._path class DataCenterNetworkService(Service): """ A service to manage a specific data center network. """ def __init__(self, connection, path): super(DataCenterNetworkService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the data center network details. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes the network. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, network, headers=None, query=None, wait=True, **kwargs ): """ Updates the network in the data center. This method supports the following parameters: `network`:: The data center network. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(network, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DataCenterNetworkService:%s' % self._path class DataCenterNetworksService(Service): """ A service to manage data center networks. """ def __init__(self, connection, path): super(DataCenterNetworksService, self).__init__(connection, path) self._network_service = None def add( self, network, headers=None, query=None, wait=True, **kwargs ): """ Create a new network in a data center. Post a request like in the example below to create a new network in a data center with an ID of `123`. [source] ---- POST /ovirt-engine/api/datacenters/123/networks ---- Use the following example in its body: [source,xml] ---- <network> <name>mynetwork</name> </network> ---- This method supports the following parameters: `network`:: The network object to be created in the data center. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(network, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists networks in the data center. The order of the returned list of networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified, all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def network_service(self, id): """ Access the data center network service that manages the data center network specified by an ID. """ Service._check_types([ ('id', id, str), ]) return DataCenterNetworkService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DataCenterNetworksService:%s' % self._path class DataCentersService(Service): """ A service to manage data centers. """ def __init__(self, connection, path): super(DataCentersService, self).__init__(connection, path) self._data_center_service = None def add( self, data_center, headers=None, query=None, wait=True, **kwargs ): """ Creates a new data center. Creation of a new data center requires the `name` and `local` elements. For example, to create a data center named `mydc` that uses shared storage (NFS, iSCSI or fibre channel) send a request like this: [source] ---- POST /ovirt-engine/api/datacenters ---- With a request body like this: [source,xml] ---- <data_center> <name>mydc</name> <local>false</local> </data_center> ---- This method supports the following parameters: `data_center`:: The data center that is being added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('data_center', data_center, types.DataCenter), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(data_center, headers, query, wait) def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the data centers. The following request retrieves a representation of the data centers: [source] ---- GET /ovirt-engine/api/datacenters ---- The above request performed with `curl`: [source,bash] ---- curl \ --request GET \ --cacert /etc/pki/ovirt-engine/ca.pem \ --header "Version: 4" \ --header "Accept: application/xml" \ --user "admin@internal:mypassword" \ https://myengine.example.com/ovirt-engine/api/datacenters ---- This is what an example response could look like: [source,xml] ---- <data_center href="/ovirt-engine/api/datacenters/123" id="123"> <name>Default</name> <description>The default Data Center</description> <link href="/ovirt-engine/api/datacenters/123/networks" rel="networks"/> <link href="/ovirt-engine/api/datacenters/123/storagedomains" rel="storagedomains"/> <link href="/ovirt-engine/api/datacenters/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/datacenters/123/clusters" rel="clusters"/> <link href="/ovirt-engine/api/datacenters/123/qoss" rel="qoss"/> <link href="/ovirt-engine/api/datacenters/123/iscsibonds" rel="iscsibonds"/> <link href="/ovirt-engine/api/datacenters/123/quotas" rel="quotas"/> <local>false</local> <quota_mode>disabled</quota_mode> <status>up</status> <supported_versions> <version> <major>4</major> <minor>0</minor> </version> </supported_versions> <version> <major>4</major> <minor>0</minor> </version> </data_center> ---- Note the `id` code of your `Default` data center. This code identifies this data center in relation to other resources of your virtual environment. The data center also contains a link to the storage domains collection. The data center uses this collection to attach storage domains from the storage domains main collection. The order of the returned list of data centers is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of data centers to return. If not specified all the data centers are returned. `search`:: A query string used to restrict the returned data centers. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def data_center_service(self, id): """ Reference to the service that manages a specific data center. """ Service._check_types([ ('id', id, str), ]) return DataCenterService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.data_center_service(path) return self.data_center_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DataCentersService:%s' % self._path class DiskAttachmentService(Service): """ This service manages the attachment of a disk to a virtual machine. """ def __init__(self, connection, path): super(DiskAttachmentService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the details of the attachment, including the bootable flag and link to the disk. An example of getting a disk attachment: [source] ---- GET /ovirt-engine/api/vms/123/diskattachments/456 ---- [source,xml] ---- <disk_attachment href="/ovirt-engine/api/vms/123/diskattachments/456" id="456"> <active>true</active> <bootable>true</bootable> <interface>virtio</interface> <disk href="/ovirt-engine/api/disks/456" id="456"/> <vm href="/ovirt-engine/api/vms/123" id="123"/> </disk_attachment> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, detach_only=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the disk attachment. This will only detach the disk from the virtual machine, but won't remove it from the system, unless the `detach_only` parameter is `false`. An example of removing a disk attachment: [source] ---- DELETE /ovirt-engine/api/vms/123/diskattachments/456?detach_only=true ---- This method supports the following parameters: `detach_only`:: Indicates if the disk should only be detached from the virtual machine, but not removed from the system. The default value is `true`, which won't remove the disk from the system. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('detach_only', detach_only, bool), ]) # Build the URL: query = query or {} if detach_only is not None: detach_only = Writer.render_boolean(detach_only) query['detach_only'] = detach_only # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, disk_attachment, headers=None, query=None, wait=True, **kwargs ): """ Update the disk attachment and the disk properties within it. [source] ---- PUT /vms/{vm:id}/disksattachments/{attachment:id} <disk_attachment> <bootable>true</bootable> <interface>ide</interface> <active>true</active> <disk> <name>mydisk</name> <provisioned_size>1024</provisioned_size> ... </disk> </disk_attachment> ---- """ # Check the types of the parameters: Service._check_types([ ('disk_attachment', disk_attachment, types.DiskAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(disk_attachment, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DiskAttachmentService:%s' % self._path class DiskAttachmentsService(Service): """ This service manages the set of disks attached to a virtual machine. Each attached disk is represented by a <<types/disk_attachment,DiskAttachment>>, containing the bootable flag, the disk interface and the reference to the disk. """ def __init__(self, connection, path): super(DiskAttachmentsService, self).__init__(connection, path) self._attachment_service = None def add( self, attachment, headers=None, query=None, wait=True, **kwargs ): """ Adds a new disk attachment to the virtual machine. The `attachment` parameter can contain just a reference, if the disk already exists: [source,xml] ---- <disk_attachment> <bootable>true</bootable> <pass_discard>true</pass_discard> <interface>ide</interface> <active>true</active> <disk id="123"/> </disk_attachment> ---- Or it can contain the complete representation of the disk, if the disk doesn't exist yet: [source,xml] ---- <disk_attachment> <bootable>true</bootable> <pass_discard>true</pass_discard> <interface>ide</interface> <active>true</active> <disk> <name>mydisk</name> <provisioned_size>1024</provisioned_size> ... </disk> </disk_attachment> ---- In this case the disk will be created and then attached to the virtual machine. In both cases, use the following URL for a virtual machine with an id `345`: [source] ---- POST /ovirt-engine/api/vms/345/diskattachments ---- IMPORTANT: The server accepts requests that don't contain the `active` attribute, but the effect is undefined. In some cases the disk will be automatically activated and in other cases it won't. To avoid issues it is strongly recommended to always include the `active` attribute with the desired value. This method supports the following parameters: `attachment`:: The disk attachment to add to the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.DiskAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(attachment, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List the disk that are attached to the virtual machine. The order of the returned list of disks attachments isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def add_providing_disk_id( self, attachment, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `attachment`:: The disk attachment to add to the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.DiskAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(attachment, headers, query, wait) def add_signature1( self, attachment, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `attachment`:: The disk attachment to add to the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.DiskAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(attachment, headers, query, wait) def attachment_service(self, id): """ Reference to the service that manages a specific attachment. """ Service._check_types([ ('id', id, str), ]) return DiskAttachmentService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.attachment_service(path) return self.attachment_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DiskAttachmentsService:%s' % self._path class DiskProfileService(Service): """ """ def __init__(self, connection, path): super(DiskProfileService, self).__init__(connection, path) self._permissions_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, profile, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified disk profile in the system. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.DiskProfile), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(profile, headers, query, wait) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DiskProfileService:%s' % self._path class DiskProfilesService(Service): """ """ def __init__(self, connection, path): super(DiskProfilesService, self).__init__(connection, path) self._disk_profile_service = None def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new disk profile to the system. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.DiskProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disk profiles of the system. The order of the returned list of disk profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return DiskProfileService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_profile_service(path) return self.disk_profile_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DiskProfilesService:%s' % self._path class DiskSnapshotService(Service): """ """ def __init__(self, connection, path): super(DiskSnapshotService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DiskSnapshotService:%s' % self._path class DiskSnapshotsService(Service): """ Manages the collection of disk snapshots available in an storage domain. """ def __init__(self, connection, path): super(DiskSnapshotsService, self).__init__(connection, path) self._snapshot_service = None def list( self, follow=None, include_active=None, include_template=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disk snapshots of the storage domain. The order of the returned list of disk snapshots isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of snapshots to return. If not specified all the snapshots are returned. `include_active`:: If true return also active snapshots. If not specified active snapshots are not returned. `include_template`:: If true return also template snapshots. If not specified template snapshots are not returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('include_active', include_active, bool), ('include_template', include_template, bool), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if include_active is not None: include_active = Writer.render_boolean(include_active) query['include_active'] = include_active if include_template is not None: include_template = Writer.render_boolean(include_template) query['include_template'] = include_template if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def snapshot_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return DiskSnapshotService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.snapshot_service(path) return self.snapshot_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DiskSnapshotsService:%s' % self._path class DisksService(Service): """ Manages the collection of disks available in the system. """ def __init__(self, connection, path): super(DisksService, self).__init__(connection, path) self._disk_service = None def add( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Adds a new floating disk. There are three types of disks that can be added - disk image, direct LUN and https://wiki.openstack.org/wiki/Cinder[Cinder] disk. *Adding a new image disk:* When creating a new floating image <<types/disk,Disk>>, the API requires the `storage_domain`, `provisioned_size` and `format` attributes. Note that block storage domains (i.e., storage domains with the <<types/storage_type, storage type>> of iSCSI or FCP) don't support the combination of the raw `format` with `sparse=true`, so `sparse=false` must be stated explicitly. To create a new floating image disk with specified `provisioned_size`, `format` and `name` on a storage domain with an id `123`, send a request as follows: [source] ---- POST /ovirt-engine/api/disks ---- With a request body as follows: [source,xml] ---- <disk> <storage_domains> <storage_domain id="123"/> </storage_domains> <name>mydisk</name> <provisioned_size>1048576</provisioned_size> <format>cow</format> </disk> ---- *Adding a new direct LUN disk:* When adding a new floating direct LUN via the API, there are two flavors that can be used: . With a `host` element - in this case, the host is used for sanity checks (e.g., that the LUN is visible) and to retrieve basic information about the LUN (e.g., size and serial). . Without a `host` element - in this case, the operation is a database-only operation, and the storage is never accessed. To create a new floating direct LUN disk with a `host` element with an id `123`, specified `alias`, `type` and `logical_unit` with an id `456` (that has the attributes `address`, `port` and `target`), send a request as follows: [source] ---- POST /ovirt-engine/api/disks ---- With a request body as follows: [source,xml] ---- <disk> <alias>mylun</alias> <lun_storage> <host id="123"/> <type>iscsi</type> <logical_units> <logical_unit id="456"> <address>10.35.10.20</address> <port>3260</port> <target>iqn.2017-01.com.myhost:444</target> </logical_unit> </logical_units> </lun_storage> </disk> ---- To create a new floating direct LUN disk without using a host, remove the `host` element. *Adding a new Cinder disk:* To create a new floating Cinder disk, send a request as follows: [source] ---- POST /ovirt-engine/api/disks ---- With a request body as follows: [source,xml] ---- <disk> <openstack_volume_type> <name>myceph</name> </openstack_volume_type> <storage_domains> <storage_domain> <name>cinderDomain</name> </storage_domain> </storage_domains> <provisioned_size>1073741824</provisioned_size> <interface>virtio</interface> <format>raw</format> </disk> ---- *Adding a floating disks in order to upload disk snapshots:* Since version 4.2 of the engine it is possible to upload disks with snapshots. This request should be used to create the base image of the images chain (The consecutive disk snapshots (images), should be created using `disk-attachments` element when creating a snapshot). The disk has to be created with the same disk identifier and image identifier of the uploaded image. I.e. the identifiers should be saved as part of the backup process. The image identifier can be also fetched using the `qemu-img info` command. For example, if the disk image is stored into a file named `b7a4c6c5-443b-47c5-967f-6abc79675e8b/myimage.img`: [source,shell] ---- $ qemu-img info b7a4c6c5-443b-47c5-967f-6abc79675e8b/myimage.img image: b548366b-fb51-4b41-97be-733c887fe305 file format: qcow2 virtual size: 1.0G (1073741824 bytes) disk size: 196K cluster_size: 65536 backing file: ad58716a-1fe9-481f-815e-664de1df04eb backing file format: raw ---- To create a disk with with the disk identifier and image identifier obtained with the `qemu-img info` command shown above, send a request like this: [source] ---- POST /ovirt-engine/api/disks ---- With a request body as follows: [source,xml] ---- <disk id="b7a4c6c5-443b-47c5-967f-6abc79675e8b"> <image_id>b548366b-fb51-4b41-97be-733c887fe305</image_id> <storage_domains> <storage_domain id="123"/> </storage_domains> <name>mydisk</name> <provisioned_size>1048576</provisioned_size> <format>cow</format> </disk> ---- This method supports the following parameters: `disk`:: The disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait) def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Get list of disks. [source] ---- GET /ovirt-engine/api/disks ---- You will get a XML response which will look like this one: [source,xml] ---- <disks> <disk id="123"> <actions>...</actions> <name>MyDisk</name> <description>MyDisk description</description> <link href="/ovirt-engine/api/disks/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/disks/123/statistics" rel="statistics"/> <actual_size>5345845248</actual_size> <alias>MyDisk alias</alias> ... <status>ok</status> <storage_type>image</storage_type> <wipe_after_delete>false</wipe_after_delete> <disk_profile id="123"/> <quota id="123"/> <storage_domains>...</storage_domains> </disk> ... </disks> ---- The order of the returned list of disks is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `search`:: A query string used to restrict the returned disks. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def add_lun( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Add a new lun disk to the storage domain. This method supports the following parameters: `disk`:: The disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait) def add_on_storage_domain( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Add a new disk to the storage domain with the specified size allocating space from the storage domain. This method supports the following parameters: `disk`:: The disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait) def disk_service(self, id): """ Reference to a service managing a specific disk. """ Service._check_types([ ('id', id, str), ]) return DiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DisksService:%s' % self._path class DomainService(Service): """ A service to view details of an authentication domain in the system. """ def __init__(self, connection, path): super(DomainService, self).__init__(connection, path) self._groups_service = None self._users_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the authentication domain information. Usage: .... GET /ovirt-engine/api/domains/5678 .... Will return the domain information: [source,xml] ---- <domain href="/ovirt-engine/api/domains/5678" id="5678"> <name>internal-authz</name> <link href="/ovirt-engine/api/domains/5678/users" rel="users"/> <link href="/ovirt-engine/api/domains/5678/groups" rel="groups"/> <link href="/ovirt-engine/api/domains/5678/users?search={query}" rel="users/search"/> <link href="/ovirt-engine/api/domains/5678/groups?search={query}" rel="groups/search"/> </domain> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def groups_service(self): """ Reference to a service to manage domain groups. """ return DomainGroupsService(self._connection, '%s/groups' % self._path) def users_service(self): """ Reference to a service to manage domain users. """ return DomainUsersService(self._connection, '%s/users' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'groups': return self.groups_service() if path.startswith('groups/'): return self.groups_service().service(path[7:]) if path == 'users': return self.users_service() if path.startswith('users/'): return self.users_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DomainService:%s' % self._path class DomainGroupService(Service): """ """ def __init__(self, connection, path): super(DomainGroupService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DomainGroupService:%s' % self._path class DomainGroupsService(Service): """ """ def __init__(self, connection, path): super(DomainGroupsService, self).__init__(connection, path) self._group_service = None def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of groups. The order of the returned list of groups isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of groups to return. If not specified all the groups are returned. `search`:: A query string used to restrict the returned groups. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def group_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return DomainGroupService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.group_service(path) return self.group_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DomainGroupsService:%s' % self._path class DomainUserService(Service): """ A service to view a domain user in the system. """ def __init__(self, connection, path): super(DomainUserService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the domain user information. Usage: .... GET /ovirt-engine/api/domains/5678/users/1234 .... Will return the domain user information: [source,xml] ---- <user href="/ovirt-engine/api/users/1234" id="1234"> <name>admin</name> <namespace>*</namespace> <principal>admin</principal> <user_name>admin@internal-authz</user_name> <domain href="/ovirt-engine/api/domains/5678" id="5678"> <name>internal-authz</name> </domain> <groups/> </user> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DomainUserService:%s' % self._path class DomainUserGroupsService(Service): """ A service that shows a user's group membership in the AAA extension. """ def __init__(self, connection, path): super(DomainUserGroupsService, self).__init__(connection, path) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of groups that the user is a member of. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DomainUserGroupsService:%s' % self._path class DomainUsersService(Service): """ A service to list all domain users in the system. """ def __init__(self, connection, path): super(DomainUsersService, self).__init__(connection, path) self._user_service = None def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ List all the users in the domain. Usage: .... GET /ovirt-engine/api/domains/5678/users .... Will return the list of users in the domain: [source,xml] ---- <users> <user href="/ovirt-engine/api/domains/5678/users/1234" id="1234"> <name>admin</name> <namespace>*</namespace> <principal>admin</principal> <user_name>admin@internal-authz</user_name> <domain href="/ovirt-engine/api/domains/5678" id="5678"> <name>internal-authz</name> </domain> <groups/> </user> </users> ---- The order of the returned list of users isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of users to return. If not specified all the users are returned. `search`:: A query string used to restrict the returned users. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def user_service(self, id): """ Reference to a service to view details of a domain user. """ Service._check_types([ ('id', id, str), ]) return DomainUserService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.user_service(path) return self.user_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DomainUsersService:%s' % self._path class DomainsService(Service): """ A service to list all authentication domains in the system. """ def __init__(self, connection, path): super(DomainsService, self).__init__(connection, path) self._domain_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all the authentication domains in the system. Usage: .... GET /ovirt-engine/api/domains .... Will return the list of domains: [source,xml] ---- <domains> <domain href="/ovirt-engine/api/domains/5678" id="5678"> <name>internal-authz</name> <link href="/ovirt-engine/api/domains/5678/users" rel="users"/> <link href="/ovirt-engine/api/domains/5678/groups" rel="groups"/> <link href="/ovirt-engine/api/domains/5678/users?search={query}" rel="users/search"/> <link href="/ovirt-engine/api/domains/5678/groups?search={query}" rel="groups/search"/> </domain> </domains> ---- The order of the returned list of domains isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of domains to return. If not specified all the domains are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def domain_service(self, id): """ Reference to a service to view details of a domain. """ Service._check_types([ ('id', id, str), ]) return DomainService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.domain_service(path) return self.domain_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DomainsService:%s' % self._path class EventService(Service): """ A service to manage an event in the system. """ def __init__(self, connection, path): super(EventService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get an event. An example of getting an event: [source] ---- GET /ovirt-engine/api/events/123 ---- [source,xml] ---- <event href="/ovirt-engine/api/events/123" id="123"> <description>Host example.com was added by admin@internal-authz.</description> <code>42</code> <correlation_id>135</correlation_id> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-12-11T11:13:44.654+02:00</time> <cluster href="/ovirt-engine/api/clusters/456" id="456"/> <host href="/ovirt-engine/api/hosts/789" id="789"/> <user href="/ovirt-engine/api/users/987" id="987"/> </event> ---- Note that the number of fields changes according to the information that resides on the event. For example, for storage domain related events you will get the storage domain reference, as well as the reference for the data center this storage domain resides in. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes an event from internal audit log. An event can be removed by sending following request [source] ---- DELETE /ovirt-engine/api/events/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'EventService:%s' % self._path class EventSubscriptionService(Service): """ A service to manage a specific event-subscription in the system. """ def __init__(self, connection, path): super(EventSubscriptionService, self).__init__(connection, path) def get( self, headers=None, query=None, wait=True, **kwargs ): """ Gets the information about the event-subscription. For example to retrieve the information about the subscription of user '123' to the event 'vm_console_detected': .... GET /ovirt-engine/api/users/123/vm_console_detected .... [source,xml] ---- <event-subscription href="/ovirt-engine/api/users/123/event-subscriptions/vm_console_detected"> <event>vm_console_detected</event> <notification_method>smtp</notification_method> <user href="/ovirt-engine/api/users/123" id="123"/> <address>a@b.com</address> </event-subscription> ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the event-subscription from the system. For example to remove user 123's subscription to `vm_console_detected` event: .... DELETE /ovirt-engine/api/users/123/vm_console_detected .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'EventSubscriptionService:%s' % self._path class EventSubscriptionsService(Service): """ Represents a service to manage collection of event-subscription of a user. """ def __init__(self, connection, path): super(EventSubscriptionsService, self).__init__(connection, path) self._event_subscription_service = None def add( self, event_subscription, headers=None, query=None, wait=True, **kwargs ): """ Add a new event-subscription to the system. An event-subscription is always added in the context of a user. For example, to add new event-subscription for `host_high_cpu_use` for user `123`, and have the notification sent to the e-mail address: `a@b.com`, send a request like this: .... POST /ovirt-engine/api/users/123/eventsubscriptions .... With a request body like this: [source,xml] ---- <event_subscription> <event>host_high_cpu_use</event> <address>a@b.com</address> </event_subscription> ---- The event name will become the ID of the new event-subscription entity: GET .../api/users/123/eventsubscriptions/host_high_cpu_use Note that no user id is provided in the request body. This is because the user-id (in this case 123) is already known to the API from the context. Note also that event-subscription entity contains notification-method field, but it is not provided either in the request body. This is because currently it's always set to SMTP as SNMP notifications are still unsupported by the API layer. This method supports the following parameters: `event_subscription`:: The added event-subscription. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('event_subscription', event_subscription, types.EventSubscription), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(event_subscription, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the event-subscriptions for the provided user. For example to list event-subscriptions for user `123`: .... GET /ovirt-engine/api/users/123/event-subscriptions .... [source,xml] ---- <event-subscriptions> <event-subscription href="/ovirt-engine/api/users/123/event-subscriptions/host_install_failed"> <event>host_install_failed</event> <notification_method>smtp</notification_method> <user href="/ovirt-engine/api/users/123" id="123"/> <address>a@b.com</address> </event-subscription> <event-subscription href="/ovirt-engine/api/users/123/event-subscriptions/vm_paused"> <event>vm_paused</event> <notification_method>smtp</notification_method> <user href="/ovirt-engine/api/users/123" id="123"/> <address>a@b.com</address> </event-subscription> </event-subscriptions> ---- This method supports the following parameters: `max`:: Sets the maximum number of event-subscriptions to return. If not specified all the event-subscriptions are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def event_subscription_service(self, id): """ Reference to the service that manages a specific event-subscription. """ Service._check_types([ ('id', id, str), ]) return EventSubscriptionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.event_subscription_service(path) return self.event_subscription_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'EventSubscriptionsService:%s' % self._path class EventsService(Service): """ A service to manage events in the system. """ def __init__(self, connection, path): super(EventsService, self).__init__(connection, path) self._event_service = None def add( self, event, headers=None, query=None, wait=True, **kwargs ): """ Adds an external event to the internal audit log. This is intended for integration with external systems that detect or produce events relevant for the administrator of the system. For example, an external monitoring tool may be able to detect that a file system is full inside the guest operating system of a virtual machine. This event can be added to the internal audit log sending a request like this: [source] ---- POST /ovirt-engine/api/events <event> <description>File system /home is full</description> <severity>alert</severity> <origin>mymonitor</origin> <custom_id>1467879754</custom_id> </event> ---- Events can also be linked to specific objects. For example, the above event could be linked to the specific virtual machine where it happened, using the `vm` link: [source] ---- POST /ovirt-engine/api/events <event> <description>File system /home is full</description> <severity>alert</severity> <origin>mymonitor</origin> <custom_id>1467879754</custom_id> <vm id="aae98225-5b73-490d-a252-899209af17e9"/> </event> ---- NOTE: When using links, like the `vm` in the previous example, only the `id` attribute is accepted. The `name` attribute, if provided, is simply ignored. """ # Check the types of the parameters: Service._check_types([ ('event', event, types.Event), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(event, headers, query, wait) def list( self, case_sensitive=None, follow=None, from_=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Get list of events. [source] ---- GET /ovirt-engine/api/events ---- To the above request we get following response: [source,xml] ---- <events> <event href="/ovirt-engine/api/events/2" id="2"> <description>User admin@internal-authz logged out.</description> <code>31</code> <correlation_id>1e892ea9</correlation_id> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-09-14T12:14:34.541+02:00</time> <user href="/ovirt-engine/api/users/57d91d48-00da-0137-0138-000000000244" id="57d91d48-00da-0137-0138-000000000244"/> </event> <event href="/ovirt-engine/api/events/1" id="1"> <description>User admin logged in.</description> <code>30</code> <correlation_id>1fbd81f4</correlation_id> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-09-14T11:54:35.229+02:00</time> <user href="/ovirt-engine/api/users/57d91d48-00da-0137-0138-000000000244" id="57d91d48-00da-0137-0138-000000000244"/> </event> </events> ---- The following events occur: * id="1" - The API logs in the admin user account. * id="2" - The API logs out of the admin user account. The order of the returned list of events is always garanteed. If the `sortby` clause is included in the `search` parameter, then the events will be ordered according to that clause. If the `sortby` clause isn't included, then the events will be sorted by the numeric value of the `id` attribute, starting with the highest value. This, combined with the `max` parameter, simplifies obtaining the most recent event: .... GET /ovirt-engine/api/events?max=1 .... This method supports the following parameters: `from_`:: Indicates the event index after which events should be returned. The indexes of events are strictly increasing, so when this parameter is used only the events with greater indexes will be returned. For example, the following request will return only the events with indexes greater than `123`: [source] ---- GET /ovirt-engine/api/events?from=123 ---- This parameter is optional, and if not specified then the first event returned will be most recently generated. `max`:: Sets the maximum number of events to return. If not specified all the events are returned. `search`:: The events service provides search queries similar to other resource services. We can search by providing specific severity. [source] ---- GET /ovirt-engine/api/events?search=severity%3Dnormal ---- To the above request we get a list of events which severity is equal to `normal`: [source,xml] ---- <events> <event href="/ovirt-engine/api/events/2" id="2"> <description>User admin@internal-authz logged out.</description> <code>31</code> <correlation_id>1fbd81f4</correlation_id> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-09-14T11:54:35.229+02:00</time> <user href="/ovirt-engine/api/users/57d91d48-00da-0137-0138-000000000244" id="57d91d48-00da-0137-0138-000000000244"/> </event> <event href="/ovirt-engine/api/events/1" id="1"> <description>Affinity Rules Enforcement Manager started.</description> <code>10780</code> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-09-14T11:52:18.861+02:00</time> </event> </events> ---- A virtualization environment generates a large amount of events after a period of time. However, the API only displays a default number of events for one search query. To display more than the default, the API separates results into pages with the page command in a search query. The following search query tells the API to paginate results using a page value in combination with the sortby clause: [source] ---- sortby time asc page 1 ---- Below example paginates event resources. The URL-encoded request is: [source] ---- GET /ovirt-engine/api/events?search=sortby%20time%20asc%20page%201 ---- Increase the page value to view the next page of results. [source] ---- GET /ovirt-engine/api/events?search=sortby%20time%20asc%20page%202 ---- `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('from_', from_, int), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if from_ is not None: from_ = Writer.render_integer(from_) query['from'] = from_ if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def undelete( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the un-delete should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'undelete', None, headers, query, wait) def event_service(self, id): """ Reference to the service that manages a specific event. """ Service._check_types([ ('id', id, str), ]) return EventService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.event_service(path) return self.event_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'EventsService:%s' % self._path class ExternalComputeResourceService(Service): """ Manages a single external compute resource. Compute resource is a term of host external provider. The external provider also needs to know to where the provisioned host needs to register. The login details of the engine are saved as a compute resource in the external provider side. """ def __init__(self, connection, path): super(ExternalComputeResourceService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves external compute resource details. For example, to get the details of compute resource `234` of provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/computeresources/234 .... It will return a response like this: [source,xml] ---- <external_compute_resource href="/ovirt-engine/api/externalhostproviders/123/computeresources/234" id="234"> <name>hostname</name> <provider>oVirt</provider> <url>https://hostname/api</url> <user>admin@internal</user> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_compute_resource> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalComputeResourceService:%s' % self._path class ExternalComputeResourcesService(Service): """ Manages a collection of external compute resources. Compute resource is a term of host external provider. The external provider also needs to know to where the provisioned host needs to register. The login details of the engine is saved as a compute resource in the external provider side. """ def __init__(self, connection, path): super(ExternalComputeResourcesService, self).__init__(connection, path) self._resource_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a list of external compute resources. For example, to retrieve the compute resources of external host provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/computeresources .... It will return a response like this: [source,xml] ---- <external_compute_resources> <external_compute_resource href="/ovirt-engine/api/externalhostproviders/123/computeresources/234" id="234"> <name>hostname</name> <provider>oVirt</provider> <url>https://address/api</url> <user>admin@internal</user> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_compute_resource> ... </external_compute_resources> ---- The order of the returned list of compute resources isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of resources to return. If not specified all the resources are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def resource_service(self, id): """ This service manages compute resource instance """ Service._check_types([ ('id', id, str), ]) return ExternalComputeResourceService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.resource_service(path) return self.resource_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ExternalComputeResourcesService:%s' % self._path class ExternalDiscoveredHostService(Service): """ This service manages a single discovered host. """ def __init__(self, connection, path): super(ExternalDiscoveredHostService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get discovered host info. Retrieves information about an host that is managed in external provider management system, such as Foreman. The information includes hostname, address, subnet, base image and more. For example, to get the details of host `234` from provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/discoveredhosts/234 .... The result will be like this: [source,xml] ---- <external_discovered_host href="/ovirt-engine/api/externalhostproviders/123/discoveredhosts/234" id="234"> <name>mac001a4ad04040</name> <ip>10.34.67.43</ip> <last_report>2017-04-24 11:05:41 UTC</last_report> <mac>00:1a:4a:d0:40:40</mac> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_discovered_host> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalDiscoveredHostService:%s' % self._path class ExternalDiscoveredHostsService(Service): """ This service manages external discovered hosts. """ def __init__(self, connection, path): super(ExternalDiscoveredHostsService, self).__init__(connection, path) self._host_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Get list of discovered hosts' information. Discovered hosts are fetched from third-party providers such as Foreman. To list all discovered hosts for provider `123` send the following: [source] ---- GET /ovirt-engine/api/externalhostproviders/123/discoveredhost ---- [source,xml] ---- <external_discovered_hosts> <external_discovered_host href="/ovirt-engine/api/externalhostproviders/123/discoveredhosts/456" id="456"> <name>mac001a4ad04031</name> <ip>10.34.67.42</ip> <last_report>2017-04-24 11:05:41 UTC</last_report> <mac>00:1a:4a:d0:40:31</mac> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_discovered_host> <external_discovered_host href="/ovirt-engine/api/externalhostproviders/123/discoveredhosts/789" id="789"> <name>mac001a4ad04040</name> <ip>10.34.67.43</ip> <last_report>2017-04-24 11:05:41 UTC</last_report> <mac>00:1a:4a:d0:40:40</mac> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_discovered_host> ... </external_discovered_hosts> ---- The order of the returned list of hosts isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of hosts to return. If not specified all the hosts are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def host_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ExternalDiscoveredHostService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ExternalDiscoveredHostsService:%s' % self._path class ExternalHostService(Service): """ """ def __init__(self, connection, path): super(ExternalHostService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalHostService:%s' % self._path class ExternalHostGroupService(Service): """ This service manages a single host group information. Host group is a term of host provider - the host group includes provision details that are applied to new discovered host. Information such as subnet, operating system, domain, etc. """ def __init__(self, connection, path): super(ExternalHostGroupService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get host group information. For example, to get the details of hostgroup `234` of provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/hostgroups/234 .... It will return a response like this: [source,xml] ---- <external_host_group href="/ovirt-engine/api/externalhostproviders/123/hostgroups/234" id="234"> <name>rhel7</name> <architecture_name>x86_64</architecture_name> <domain_name>s.com</domain_name> <operating_system_name>RedHat 7.3</operating_system_name> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_host_group> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalHostGroupService:%s' % self._path class ExternalHostGroupsService(Service): """ This service manages hostgroups. """ def __init__(self, connection, path): super(ExternalHostGroupsService, self).__init__(connection, path) self._group_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Get host groups list from external host provider. Host group is a term of host providers - the host group includes provision details. This API returns all possible hostgroups exposed by the external provider. For example, to get the details of all host groups of provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/hostgroups .... The response will be like this: [source,xml] ---- <external_host_groups> <external_host_group href="/ovirt-engine/api/externalhostproviders/123/hostgroups/234" id="234"> <name>rhel7</name> <architecture_name>x86_64</architecture_name> <domain_name>example.com</domain_name> <operating_system_name>RedHat 7.3</operating_system_name> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_host_group> ... </external_host_groups> ---- The order of the returned list of host groups isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of groups to return. If not specified all the groups are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def group_service(self, id): """ This service manages hostgroup instance. """ Service._check_types([ ('id', id, str), ]) return ExternalHostGroupService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.group_service(path) return self.group_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ExternalHostGroupsService:%s' % self._path class ExternalHostProvidersService(Service): """ """ def __init__(self, connection, path): super(ExternalHostProvidersService, self).__init__(connection, path) self._provider_service = None def add( self, provider, headers=None, query=None, wait=True, **kwargs ): """ Add a new external host provider to the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.ExternalHostProvider), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(provider, headers, query, wait) def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of external host providers. The order of the returned list of host providers isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of providers to return. If not specified all the providers are returned. `search`:: A query string used to restrict the returned external host providers. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def provider_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ExternalHostProviderService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.provider_service(path) return self.provider_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ExternalHostProvidersService:%s' % self._path class ExternalHostsService(Service): """ """ def __init__(self, connection, path): super(ExternalHostsService, self).__init__(connection, path) self._host_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Return the list of external hosts. The order of the returned list of hosts isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of hosts to return. If not specified all the hosts are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def host_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ExternalHostService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ExternalHostsService:%s' % self._path class ExternalNetworkProviderConfigurationService(Service): """ Describes how an external network provider is provisioned by the system on the host. """ def __init__(self, connection, path): super(ExternalNetworkProviderConfigurationService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about an external network provider on the host. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalNetworkProviderConfigurationService:%s' % self._path class ExternalNetworkProviderConfigurationsService(Service): """ A service to list all external network providers provisioned by the system on the host. """ def __init__(self, connection, path): super(ExternalNetworkProviderConfigurationsService, self).__init__(connection, path) self._configuration_service = None def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of all external network providers on the host. The order of the returned list of networks is not guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def configuration_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ExternalNetworkProviderConfigurationService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.configuration_service(path) return self.configuration_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ExternalNetworkProviderConfigurationsService:%s' % self._path class ExternalProviderService(Service): """ Provides capability to manage external providers. """ def __init__(self, connection, path): super(ExternalProviderService, self).__init__(connection, path) self._certificates_service = None def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait) def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait) def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalProviderService:%s' % self._path class ExternalProviderCertificateService(Service): """ A service to view specific certificate for external provider. """ def __init__(self, connection, path): super(ExternalProviderCertificateService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get specific certificate. [source] ---- GET /ovirt-engine/api/externalhostproviders/123/certificate/0 ---- And here is sample response: [source,xml] ---- <certificate id="0"> <organization>provider.example.com</organization> <subject>CN=provider.example.com</subject> <content>...</content> </certificate> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalProviderCertificateService:%s' % self._path class ExternalProviderCertificatesService(Service): """ A service to view certificates for external provider. """ def __init__(self, connection, path): super(ExternalProviderCertificatesService, self).__init__(connection, path) self._certificate_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the chain of certificates presented by the external provider. [source] ---- GET /ovirt-engine/api/externalhostproviders/123/certificates ---- And here is sample response: [source,xml] ---- <certificates> <certificate id="789">...</certificate> ... </certificates> ---- The order of the returned certificates is always guaranteed to be the sign order: the first is the certificate of the server itself, the second the certificate of the CA that signs the first, so on. This method supports the following parameters: `max`:: Sets the maximum number of certificates to return. If not specified all the certificates are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def certificate_service(self, id): """ Reference to service that manages a specific certificate for this external provider. """ Service._check_types([ ('id', id, str), ]) return ExternalProviderCertificateService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.certificate_service(path) return self.certificate_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ExternalProviderCertificatesService:%s' % self._path class ExternalTemplateImportsService(Service): """ Provides capability to import external templates. Currently supports OVA only. """ def __init__(self, connection, path): super(ExternalTemplateImportsService, self).__init__(connection, path) def add( self, import_, headers=None, query=None, wait=True, **kwargs ): """ This operation is used to import a template from external hypervisor. For example import of a template OVA can be facilitated using the following request: [source] ---- POST /externaltemplateimports ---- With request body of type <<types/external_template_import,ExternalTemplateImport>>, for example: [source,xml] ---- <external_template_import> <template> <name>my_template</name> </template> <cluster id="2b18aca2-4469-11eb-9449-482ae35a5f83" /> <storage_domain id="8bb5ade5-e988-4000-8b93-dbfc6717fe50" /> <url>ova:///mnt/ova/ova_template.ova</url> <host id="8bb5ade5-e988-4000-8b93-dbfc6717fe50" /> </external_template_import> ---- """ # Check the types of the parameters: Service._check_types([ ('import_', import_, types.ExternalTemplateImport), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(import_, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalTemplateImportsService:%s' % self._path class ExternalVmImportsService(Service): """ Provides capability to import external virtual machines. """ def __init__(self, connection, path): super(ExternalVmImportsService, self).__init__(connection, path) def add( self, import_, headers=None, query=None, wait=True, **kwargs ): """ This operation is used to import a virtual machine from external hypervisor, such as KVM, XEN or VMware. For example import of a virtual machine from VMware can be facilitated using the following request: [source] ---- POST /externalvmimports ---- With request body of type <<types/external_vm_import,ExternalVmImport>>, for example: [source,xml] ---- <external_vm_import> <vm> <name>my_vm</name> </vm> <cluster id="360014051136c20574f743bdbd28177fd" /> <storage_domain id="8bb5ade5-e988-4000-8b93-dbfc6717fe50" /> <name>vm_name_as_is_in_vmware</name> <sparse>true</sparse> <username>vmware_user</username> <password>123456</password> <provider>VMWARE</provider> <url>vpx://wmware_user@vcenter-host/DataCenter/Cluster/esxi-host?no_verify=1</url> <drivers_iso id="virtio-win-1.6.7.iso" /> </external_vm_import> ---- """ # Check the types of the parameters: Service._check_types([ ('import_', import_, types.ExternalVmImport), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(import_, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalVmImportsService:%s' % self._path class FenceAgentService(Service): """ A service to manage fence agent for a specific host. """ def __init__(self, connection, path): super(FenceAgentService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets details of this fence agent. [source] ---- GET /ovirt-engine/api/hosts/123/fenceagents/0 ---- And here is sample response: [source,xml] ---- <agent id="0"> <type>apc</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <port>9</port> <options>name1=value1, name2=value2</options> </agent> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a fence agent for a specific host. [source] ---- DELETE /ovirt-engine/api/hosts/123/fenceagents/0 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, agent, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update a fencing-agent. This method supports the following parameters: `agent`:: Fence agent details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('agent', agent, types.Agent), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(agent, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'FenceAgentService:%s' % self._path class FenceAgentsService(Service): """ A service to manage fence agents for a specific host. """ def __init__(self, connection, path): super(FenceAgentsService, self).__init__(connection, path) self._agent_service = None def add( self, agent, headers=None, query=None, wait=True, **kwargs ): """ Add a new fencing-agent to the host. [source] ---- POST /ovirt-engine/api/hosts/123/fenceagents You should consult the /usr/sbin/fence_<agent_name> manual page for the legal parameters to [name1=value1, name2=value2,...] in the options field. If any parameter in options appears by name that means that it is mandatory. For example in <options>slot=7[,name1=value1, name2=value2,...]</options> slot is mandatory. ---- apc, bladecenter, wti fencing agent/s sample request: [source,xml] <agent> <type>apc</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <port>9</port> <options>slot=7[,name1=value1, name2=value2,...]</options> </agent> apc_snmp, hpblade, ilo, ilo2, ilo_ssh, redfish, rsa fencing agent/s sample request: [source,xml] <agent> <type>apc_snmp</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <port>9</port> <options>[name1=value1, name2=value2,...]</options> </agent> cisco_ucs, drac5, eps fencing agent/s sample request: [source,xml] <agent> <type>cisco_ucs</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <options>slot=7[,name1=value1, name2=value2,...]</options> </agent> drac7, ilo3, ilo4, ipmilan, rsb fencing agent/s sample request: [source,xml] <agent> <type>drac7</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <options>[name1=value1, name2=value2,...]</options> </agent> """ # Check the types of the parameters: Service._check_types([ ('agent', agent, types.Agent), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(agent, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of fencing agents configured for the host. [source] ---- GET /ovirt-engine/api/hosts/123/fenceagents ---- And here is sample response: [source,xml] ---- <agents> <agent id="0"> <type>apc</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <port>9</port> <options>name1=value1, name2=value2</options> </agent> </agents> ---- The order of the returned list of fencing agents isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of agents to return. If not specified all the agents are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def agent_service(self, id): """ Reference to service that manages a specific fence agent for this host. """ Service._check_types([ ('id', id, str), ]) return FenceAgentService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.agent_service(path) return self.agent_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'FenceAgentsService:%s' % self._path class FileService(Service): """ """ def __init__(self, connection, path): super(FileService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'FileService:%s' % self._path class FilesService(Service): """ Provides a way for clients to list available files. This service is specifically targeted to ISO storage domains, which contain ISO images and virtual floppy disks (VFDs) that an administrator uploads. The addition of a CD-ROM device to a virtual machine requires an ISO image from the files of an ISO storage domain. """ def __init__(self, connection, path): super(FilesService, self).__init__(connection, path) self._file_service = None def list( self, case_sensitive=None, follow=None, max=None, refresh=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of ISO images and virtual floppy disks available in the storage domain. The order of the returned list is not guaranteed. If the `refresh` parameter is `false`, the returned list may not reflect recent changes to the storage domain; for example, it may not contain a new ISO file that was recently added. This is because the server caches the list of files to improve performance. To get the very latest results, set the `refresh` parameter to `true`. The default value of the `refresh` parameter is `true`, but it can be changed using the configuration value `ForceRefreshDomainFilesByDefault`: [source] ---- # engine-config -s ForceRefreshDomainFilesByDefault=false ---- IMPORTANT: Setting the value of the `refresh` parameter to `true` has an impact on the performance of the server. Use it only if necessary. This method supports the following parameters: `max`:: Sets the maximum number of files to return. If not specified, all the files are returned. `search`:: A query string used to restrict the returned files. `case_sensitive`:: Indicates if the search performed using the `search` parameter should take case into account. The default value is `true`. `refresh`:: Indicates whether the list of files should be refreshed from the storage domain, rather than showing cached results that are updated at certain intervals. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('refresh', refresh, bool), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if refresh is not None: refresh = Writer.render_boolean(refresh) query['refresh'] = refresh if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def file_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return FileService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.file_service(path) return self.file_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'FilesService:%s' % self._path class FilterService(Service): """ """ def __init__(self, connection, path): super(FilterService, self).__init__(connection, path) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'FilterService:%s' % self._path class FiltersService(Service): """ Manages the filters used by an scheduling policy. """ def __init__(self, connection, path): super(FiltersService, self).__init__(connection, path) self._filter_service = None def add( self, filter, headers=None, query=None, wait=True, **kwargs ): """ Add a filter to a specified user defined scheduling policy. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, types.Filter), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(filter, headers, query, wait) def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of filters used by the scheduling policy. The order of the returned list of filters isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of filters to return. If not specified all the filters are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def filter_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return FilterService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.filter_service(path) return self.filter_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'FiltersService:%s' % self._path class FollowService(Service): """ """ def __init__(self, connection, path): super(FollowService, self).__init__(connection, path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'FollowService:%s' % self._path class GlusterBricksService(Service): """ This service manages the gluster bricks in a gluster volume """ def __init__(self, connection, path): super(GlusterBricksService, self).__init__(connection, path) self._brick_service = None def activate( self, async_=None, bricks=None, headers=None, query=None, wait=True, **kwargs ): """ Activate the bricks post data migration of remove brick operation. Used to activate brick(s) once the data migration from bricks is complete but user no longer wishes to remove bricks. The bricks that were previously marked for removal will now be used as normal bricks. For example, to retain the bricks that on glustervolume `123` from which data was migrated, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/activate ---- With a request body like this: [source,xml] ---- <action> <bricks> <brick> <name>host1:/rhgs/brick1</name> </brick> </bricks> </action> ---- This method supports the following parameters: `bricks`:: The list of bricks that need to be re-activated. `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('bricks', bricks, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, bricks=bricks, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait) def add( self, bricks, replica_count=None, stripe_count=None, headers=None, query=None, wait=True, **kwargs ): """ Adds a list of bricks to gluster volume. Used to expand a gluster volume by adding bricks. For replicated volume types, the parameter `replica_count` needs to be passed. In case the replica count is being increased, then the number of bricks needs to be equivalent to the number of replica sets. For example, to add bricks to gluster volume `123`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks ---- With a request body like this: [source,xml] ---- <bricks> <brick> <server_id>111</server_id> <brick_dir>/export/data/brick3</brick_dir> </brick> </bricks> ---- This method supports the following parameters: `bricks`:: The list of bricks to be added to the volume `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bricks', bricks, list), ('replica_count', replica_count, int), ('stripe_count', stripe_count, int), ]) # Build the URL: query = query or {} if replica_count is not None: replica_count = Writer.render_integer(replica_count) query['replica_count'] = replica_count if stripe_count is not None: stripe_count = Writer.render_integer(stripe_count) query['stripe_count'] = stripe_count # Send the request and wait for the response: return self._internal_add(bricks, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the bricks of a gluster volume. For example, to list bricks of gluster volume `123`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks ---- Provides an output as below: [source,xml] ---- <bricks> <brick id="234"> <name>host1:/rhgs/data/brick1</name> <brick_dir>/rhgs/data/brick1</brick_dir> <server_id>111</server_id> <status>up</status> </brick> <brick id="233"> <name>host2:/rhgs/data/brick1</name> <brick_dir>/rhgs/data/brick1</brick_dir> <server_id>222</server_id> <status>up</status> </brick> </bricks> ---- The order of the returned list is based on the brick order provided at gluster volume creation. This method supports the following parameters: `max`:: Sets the maximum number of bricks to return. If not specified all the bricks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def migrate( self, async_=None, bricks=None, headers=None, query=None, wait=True, **kwargs ): """ Start migration of data prior to removing bricks. Removing bricks is a two-step process, where the data on bricks to be removed, is first migrated to remaining bricks. Once migration is completed the removal of bricks is confirmed via the API <<services/gluster_bricks/methods/remove, remove>>. If at any point, the action needs to be cancelled <<services/gluster_bricks/methods/stop_migrate, stopmigrate>> has to be called. For instance, to delete a brick from a gluster volume with id `123`, send a request: [source] ---- POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/migrate ---- With a request body like this: [source,xml] ---- <action> <bricks> <brick> <name>host1:/rhgs/brick1</name> </brick> </bricks> </action> ---- The migration process can be tracked from the job id returned from the API using <<services/job/methods/get, job>> and steps in job using <<services/step/methods/get, step>> This method supports the following parameters: `bricks`:: List of bricks for which data migration needs to be started. `async_`:: Indicates if the migration should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('bricks', bricks, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, bricks=bricks, ) # Send the request and wait for the response: return self._internal_action(action, 'migrate', None, headers, query, wait) def remove( self, bricks=None, replica_count=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes bricks from gluster volume. The recommended way to remove bricks without data loss is to first migrate the data using <<services/gluster_bricks/methods/stop_migrate, stopmigrate>> and then removing them. If migrate was not called on bricks prior to remove, the bricks are removed without data migration which may lead to data loss. For example, to delete the bricks from gluster volume `123`, send a request like this: [source] ---- DELETE /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks ---- With a request body like this: [source,xml] ---- <bricks> <brick> <name>host:brick_directory</name> </brick> </bricks> ---- This method supports the following parameters: `bricks`:: The list of bricks to be removed `replica_count`:: Replica count of volume post add operation. `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bricks', bricks, list), ('replica_count', replica_count, int), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if bricks is not None: query['bricks'] = bricks if replica_count is not None: replica_count = Writer.render_integer(replica_count) query['replica_count'] = replica_count if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def stop_migrate( self, async_=None, bricks=None, headers=None, query=None, wait=True, **kwargs ): """ Stops migration of data from bricks for a remove brick operation. To cancel data migration that was started as part of the 2-step remove brick process in case the user wishes to continue using the bricks. The bricks that were marked for removal will function as normal bricks post this operation. For example, to stop migration of data from the bricks of gluster volume `123`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/stopmigrate ---- With a request body like this: [source,xml] ---- <bricks> <brick> <name>host:brick_directory</name> </brick> </bricks> ---- This method supports the following parameters: `bricks`:: List of bricks for which data migration needs to be stopped. This list should match the arguments passed to <<services/gluster_bricks/methods/migrate, migrate>>. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('bricks', bricks, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, bricks=bricks, ) # Send the request and wait for the response: return self._internal_action(action, 'stopmigrate', None, headers, query, wait) def brick_service(self, id): """ Returns a reference to the service managing a single gluster brick. """ Service._check_types([ ('id', id, str), ]) return GlusterBrickService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.brick_service(path) return self.brick_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'GlusterBricksService:%s' % self._path class GlusterHookService(Service): """ """ def __init__(self, connection, path): super(GlusterHookService, self).__init__(connection, path) def disable( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Resolves status conflict of hook among servers in cluster by disabling Gluster hook in all servers of the cluster. This updates the hook status to `DISABLED` in database. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'disable', None, headers, query, wait) def enable( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Resolves status conflict of hook among servers in cluster by disabling Gluster hook in all servers of the cluster. This updates the hook status to `DISABLED` in database. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'enable', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the this Gluster hook from all servers in cluster and deletes it from the database. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def resolve( self, async_=None, host=None, resolution_type=None, headers=None, query=None, wait=True, **kwargs ): """ Resolves missing hook conflict depending on the resolution type. For `ADD` resolves by copying hook stored in engine database to all servers where the hook is missing. The engine maintains a list of all servers where hook is missing. For `COPY` resolves conflict in hook content by copying hook stored in engine database to all servers where the hook is missing. The engine maintains a list of all servers where the content is conflicting. If a host id is passed as parameter, the hook content from the server is used as the master to copy to other servers in cluster. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('host', host, types.Host), ('resolution_type', resolution_type, str), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, host=host, resolution_type=resolution_type, ) # Send the request and wait for the response: return self._internal_action(action, 'resolve', None, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'GlusterHookService:%s' % self._path class GlusterHooksService(Service): """ """ def __init__(self, connection, path): super(GlusterHooksService, self).__init__(connection, path) self._hook_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of hooks. The order of the returned list of hooks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of hooks to return. If not specified all the hooks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def hook_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return GlusterHookService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.hook_service(path) return self.hook_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'GlusterHooksService:%s' % self._path class GlusterVolumesService(Service): """ This service manages a collection of gluster volumes available in a cluster. """ def __init__(self, connection, path): super(GlusterVolumesService, self).__init__(connection, path) self._volume_service = None def add( self, volume, headers=None, query=None, wait=True, **kwargs ): """ Creates a new gluster volume. The volume is created based on properties of the `volume` parameter. The properties `name`, `volume_type` and `bricks` are required. For example, to add a volume with name `myvolume` to the cluster `123`, send the following request: [source] ---- POST /ovirt-engine/api/clusters/123/glustervolumes ---- With the following request body: [source,xml] ---- <gluster_volume> <name>myvolume</name> <volume_type>replicate</volume_type> <replica_count>3</replica_count> <bricks> <brick> <server_id>server1</server_id> <brick_dir>/exp1</brick_dir> </brick> <brick> <server_id>server2</server_id> <brick_dir>/exp1</brick_dir> </brick> <brick> <server_id>server3</server_id> <brick_dir>/exp1</brick_dir> </brick> <bricks> </gluster_volume> ---- This method supports the following parameters: `volume`:: The gluster volume definition from which to create the volume is passed as input and the newly created volume is returned. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('volume', volume, types.GlusterVolume), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(volume, headers, query, wait) def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all gluster volumes in the cluster. For example, to list all Gluster Volumes in cluster `456`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/456/glustervolumes ---- The order of the returned list of volumes isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of volumes to return. If not specified all the volumes are returned. `search`:: A query string used to restrict the returned volumes. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def volume_service(self, id): """ Reference to a service managing gluster volume. """ Service._check_types([ ('id', id, str), ]) return GlusterVolumeService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.volume_service(path) return self.volume_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'GlusterVolumesService:%s' % self._path class GroupService(Service): """ Manages a group of users. Use this service to either get groups details or remove groups. In order to add new groups please use <<services/groups, service>> that manages the collection of groups. """ def __init__(self, connection, path): super(GroupService, self).__init__(connection, path) self._permissions_service = None self._roles_service = None self._tags_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the system group information. Usage: .... GET /ovirt-engine/api/groups/123 .... Will return the group information: [source,xml] ---- <group href="/ovirt-engine/api/groups/123" id="123"> <name>mygroup</name> <link href="/ovirt-engine/api/groups/123/roles" rel="roles"/> <link href="/ovirt-engine/api/groups/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/groups/123/tags" rel="tags"/> <domain_entry_id>476652557A382F67696B6D2B32762B37796E46476D513D3D</domain_entry_id> <namespace>DC=example,DC=com</namespace> <domain href="/ovirt-engine/api/domains/ABCDEF" id="ABCDEF"> <name>myextension-authz</name> </domain> </group> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the system group. Usage: .... DELETE /ovirt-engine/api/groups/123 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def permissions_service(self): """ Reference to the service that manages the collection of permissions assigned to this system group. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def roles_service(self): """ Reference to the service that manages the collection of roles assigned to this system group. """ return AssignedRolesService(self._connection, '%s/roles' % self._path) def tags_service(self): """ Reference to the service that manages the collection of tags assigned to this system group. """ return AssignedTagsService(self._connection, '%s/tags' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'roles': return self.roles_service() if path.startswith('roles/'): return self.roles_service().service(path[6:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'GroupService:%s' % self._path class GroupsService(Service): """ Manages the collection of groups of users. """ def __init__(self, connection, path): super(GroupsService, self).__init__(connection, path) self._group_service = None def add( self, group, headers=None, query=None, wait=True, **kwargs ): """ Add group from a directory service. Please note that domain name is name of the authorization provider. For example, to add the `Developers` group from the `internal-authz` authorization provider send a request like this: [source] ---- POST /ovirt-engine/api/groups ---- With a request body like this: [source,xml] ---- <group> <name>Developers</name> <domain> <name>internal-authz</name> </domain> </group> ---- This method supports the following parameters: `group`:: The group to be added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('group', group, types.Group), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(group, headers, query, wait) def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ List all the groups in the system. Usage: .... GET /ovirt-engine/api/groups .... Will return the list of groups: [source,xml] ---- <groups> <group href="/ovirt-engine/api/groups/123" id="123"> <name>mygroup</name> <link href="/ovirt-engine/api/groups/123/roles" rel="roles"/> <link href="/ovirt-engine/api/groups/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/groups/123/tags" rel="tags"/> <domain_entry_id>476652557A382F67696B6D2B32762B37796E46476D513D3D</domain_entry_id> <namespace>DC=example,DC=com</namespace> <domain href="/ovirt-engine/api/domains/ABCDEF" id="ABCDEF"> <name>myextension-authz</name> </domain> </group> ... </groups> ---- The order of the returned list of groups isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of groups to return. If not specified all the groups are returned. `search`:: A query string used to restrict the returned groups. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def group_service(self, id): """ Reference to the service that manages a specific group. """ Service._check_types([ ('id', id, str), ]) return GroupService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.group_service(path) return self.group_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'GroupsService:%s' % self._path class HostDeviceService(Service): """ A service to access a particular device of a host. """ def __init__(self, connection, path): super(HostDeviceService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieve information about a particular host's device. An example of getting a host device: [source] ---- GET /ovirt-engine/api/hosts/123/devices/456 ---- [source,xml] ---- <host_device href="/ovirt-engine/api/hosts/123/devices/456" id="456"> <name>usb_1_9_1_1_0</name> <capability>usb</capability> <host href="/ovirt-engine/api/hosts/123" id="123"/> <parent_device href="/ovirt-engine/api/hosts/123/devices/789" id="789"> <name>usb_1_9_1</name> </parent_device> </host_device> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'HostDeviceService:%s' % self._path class HostDevicesService(Service): """ A service to access host devices. """ def __init__(self, connection, path): super(HostDevicesService, self).__init__(connection, path) self._device_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the devices of a host. The order of the returned list of devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of devices to return. If not specified all the devices are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def device_service(self, id): """ Reference to the service that can be used to access a specific host device. """ Service._check_types([ ('id', id, str), ]) return HostDeviceService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.device_service(path) return self.device_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'HostDevicesService:%s' % self._path class HostHookService(Service): """ """ def __init__(self, connection, path): super(HostHookService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'HostHookService:%s' % self._path class HostHooksService(Service): """ """ def __init__(self, connection, path): super(HostHooksService, self).__init__(connection, path) self._hook_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of hooks configured for the host. The order of the returned list of hooks is random. This method supports the following parameters: `max`:: Sets the maximum number of hooks to return. If not specified, all the hooks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def hook_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return HostHookService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.hook_service(path) return self.hook_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'HostHooksService:%s' % self._path class HostNicsService(Service): """ A service to manage the network interfaces of a host. """ def __init__(self, connection, path): super(HostNicsService, self).__init__(connection, path) self._nic_service = None def list( self, all_content=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of network interfaces of the host. The order of the returned list of network interfaces isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `all_content`:: Indicates if all of the attributes of the host network interface should be included in the response. By default the following attributes are excluded: - `virtual_functions_configuration` For example, to retrieve the complete representation of network interface '456' of host '123': .... GET /ovirt-engine/api/hosts/123/nics?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. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def nic_service(self, id): """ Reference to the service that manages a single network interface. """ Service._check_types([ ('id', id, str), ]) return HostNicService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'HostNicsService:%s' % self._path class HostNumaNodesService(Service): """ """ def __init__(self, connection, path): super(HostNumaNodesService, self).__init__(connection, path) self._node_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of NUMA nodes of the host. The order of the returned list of NUMA nodes isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of nodes to return. If not specified all the nodes are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def node_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return HostNumaNodeService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.node_service(path) return self.node_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'HostNumaNodesService:%s' % self._path class HostStorageService(Service): """ A service to manage host storages. """ def __init__(self, connection, path): super(HostStorageService, self).__init__(connection, path) self._storage_service = None def list( self, follow=None, report_status=None, headers=None, query=None, wait=True, **kwargs ): """ Get list of storages. [source] ---- GET /ovirt-engine/api/hosts/123/storage ---- The XML response you get will be like this one: [source,xml] ---- <host_storages> <host_storage id="123"> ... </host_storage> ... </host_storages> ---- The order of the returned list of storages isn't guaranteed. This method supports the following parameters: `report_status`:: Indicates if the status of the LUNs in the storage should be checked. Checking the status of the LUN is an heavy weight operation and this data is not always needed by the user. This parameter will give the option to not perform the status check of the LUNs. The default is `true` for backward compatibility. Here an example with the LUN status : [source,xml] ---- <host_storage id="123"> <logical_units> <logical_unit id="123"> <lun_mapping>0</lun_mapping> <paths>1</paths> <product_id>lun0</product_id> <serial>123</serial> <size>10737418240</size> <status>used</status> <vendor_id>LIO-ORG</vendor_id> <volume_group_id>123</volume_group_id> </logical_unit> </logical_units> <type>iscsi</type> <host id="123"/> </host_storage> ---- Here an example without the LUN status : [source,xml] ---- <host_storage id="123"> <logical_units> <logical_unit id="123"> <lun_mapping>0</lun_mapping> <paths>1</paths> <product_id>lun0</product_id> <serial>123</serial> <size>10737418240</size> <vendor_id>LIO-ORG</vendor_id> <volume_group_id>123</volume_group_id> </logical_unit> </logical_units> <type>iscsi</type> <host id="123"/> </host_storage> ---- `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('report_status', report_status, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if report_status is not None: report_status = Writer.render_boolean(report_status) query['report_status'] = report_status # Send the request and wait for the response: return self._internal_get(headers, query, wait) def storage_service(self, id): """ Reference to a service managing the storage. """ Service._check_types([ ('id', id, str), ]) return StorageService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_service(path) return self.storage_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'HostStorageService:%s' % self._path class HostsService(Service): """ A service that manages hosts. """ def __init__(self, connection, path): super(HostsService, self).__init__(connection, path) self._host_service = None def add( self, host, activate=None, deploy_hosted_engine=None, reboot=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ Creates a new host. The host is created based on the attributes of the `host` parameter. The `name`, `address`, and `root_password` properties are required. For example, to add a host, send the following request: [source] ---- POST /ovirt-engine/api/hosts ---- With the following request body: [source,xml] ---- <host> <name>myhost</name> <address>myhost.example.com</address> <root_password>myrootpassword</root_password> </host> ---- NOTE: The `root_password` element is only included in the client-provided initial representation and is not exposed in the representations returned from subsequent requests. IMPORTANT: Since version 4.1.2 of the engine, when a host is newly added, the host's firewall definitions are overridden by default. To add a hosted engine host, use the optional `deploy_hosted_engine` parameter: [source] ---- POST /ovirt-engine/api/hosts?deploy_hosted_engine=true ---- If the cluster has a default external network provider that is supported for automatic deployment, the external network provider is deployed when adding the host. Only external network providers for OVN are supported for the automatic deployment. To deploy an external network provider other than the one defined in the clusters, overwrite the external network provider when adding hosts, by sending the following request: [source] ---- POST /ovirt-engine/api/hosts ---- With a request body that contains a reference to the desired provider in the `external_network_provider_configuration`: [source,xml] ---- <host> <name>myhost</name> <address>myhost.example.com</address> <root_password>123456</root_password> <external_network_provider_configurations> <external_network_provider_configuration> <external_network_provider name="ovirt-provider-ovn"/> </external_network_provider_configuration> </external_network_provider_configurations> </host> ---- This method supports the following parameters: `host`:: The host definition with which the new host is created is passed as a parameter, and the newly created host is returned. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('activate', activate, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('reboot', reboot, bool), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Build the URL: query = query or {} if activate is not None: activate = Writer.render_boolean(activate) query['activate'] = activate if deploy_hosted_engine is not None: deploy_hosted_engine = Writer.render_boolean(deploy_hosted_engine) query['deploy_hosted_engine'] = deploy_hosted_engine if reboot is not None: reboot = Writer.render_boolean(reboot) query['reboot'] = reboot if undeploy_hosted_engine is not None: undeploy_hosted_engine = Writer.render_boolean(undeploy_hosted_engine) query['undeploy_hosted_engine'] = undeploy_hosted_engine # Send the request and wait for the response: return self._internal_add(host, headers, query, wait) def list( self, all_content=None, case_sensitive=None, check_vms_in_affinity_closure=None, filter=None, follow=None, max=None, migration_target_of=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Get a list of all available hosts. For example, to list the hosts send the following request: .... GET /ovirt-engine/api/hosts .... The response body will be similar to this: [source,xml] ---- <hosts> <host href="/ovirt-engine/api/hosts/123" id="123"> ... </host> <host href="/ovirt-engine/api/hosts/456" id="456"> ... </host> ... </host> ---- The order of the returned list of hosts is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of hosts to return. If not specified all the hosts are returned. `search`:: A query string used to restrict the returned hosts. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `all_content`:: Indicates if all of the attributes of the hosts should be included in the response. By default the following host attributes are excluded: - `hosted_engine` For example, to retrieve the complete representation of the hosts: .... GET /ovirt-engine/api/hosts?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. `migration_target_of`:: Accepts a comma-separated list of virtual machine IDs and returns the hosts that these virtual machines can be migrated to. For example, to retrieve the list of hosts to which the virtual machine with ID 123 and the virtual machine with ID 456 can be migrated to, send the following request: .... GET /ovirt-engine/api/hosts?migration_target_of=123,456 .... `check_vms_in_affinity_closure`:: This parameter can be used with `migration_target_of` to get valid migration targets for the listed virtual machines and all other virtual machines that are in positive enforcing affinity with the listed virtual machines. This is useful in case the virtual machines will be migrated together with others in positive affinity groups. The default value is `false`. .... GET /ovirt-engine/api/hosts?migration_target_of=123,456&check_vms_in_affinity_closure=true .... `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('case_sensitive', case_sensitive, bool), ('check_vms_in_affinity_closure', check_vms_in_affinity_closure, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('migration_target_of', migration_target_of, str), ('search', search, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if check_vms_in_affinity_closure is not None: check_vms_in_affinity_closure = Writer.render_boolean(check_vms_in_affinity_closure) query['check_vms_in_affinity_closure'] = check_vms_in_affinity_closure if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if migration_target_of is not None: query['migration_target_of'] = migration_target_of if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def add_using_root_password( self, host, activate=None, deploy_hosted_engine=None, reboot=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ Add a new host to the system providing the host root password. This has been deprecated and provided for backwards compatibility. This method supports the following parameters: `host`:: The host definition with which the new host is created is passed as a parameter, and the newly created host is returned. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('activate', activate, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('reboot', reboot, bool), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Build the URL: query = query or {} if activate is not None: activate = Writer.render_boolean(activate) query['activate'] = activate if deploy_hosted_engine is not None: deploy_hosted_engine = Writer.render_boolean(deploy_hosted_engine) query['deploy_hosted_engine'] = deploy_hosted_engine if reboot is not None: reboot = Writer.render_boolean(reboot) query['reboot'] = reboot if undeploy_hosted_engine is not None: undeploy_hosted_engine = Writer.render_boolean(undeploy_hosted_engine) query['undeploy_hosted_engine'] = undeploy_hosted_engine # Send the request and wait for the response: return self._internal_add(host, headers, query, wait) def add_using_ssh( self, host, activate=None, deploy_hosted_engine=None, reboot=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ Add a new host to the system providing the ssh password, fingerprint or public key. This method supports the following parameters: `host`:: The host definition with which the new host is created is passed as a parameter, and the newly created host is returned. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('activate', activate, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('reboot', reboot, bool), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Build the URL: query = query or {} if activate is not None: activate = Writer.render_boolean(activate) query['activate'] = activate if deploy_hosted_engine is not None: deploy_hosted_engine = Writer.render_boolean(deploy_hosted_engine) query['deploy_hosted_engine'] = deploy_hosted_engine if reboot is not None: reboot = Writer.render_boolean(reboot) query['reboot'] = reboot if undeploy_hosted_engine is not None: undeploy_hosted_engine = Writer.render_boolean(undeploy_hosted_engine) query['undeploy_hosted_engine'] = undeploy_hosted_engine # Send the request and wait for the response: return self._internal_add(host, headers, query, wait) def host_service(self, id): """ A Reference to service managing a specific host. """ Service._check_types([ ('id', id, str), ]) return HostService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'HostsService:%s' % self._path class IconService(Service): """ A service to manage an icon (read-only). """ def __init__(self, connection, path): super(IconService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get an icon. [source] ---- GET /ovirt-engine/api/icons/123 ---- You will get a XML response like this one: [source,xml] ---- <icon id="123"> <data>Some binary data here</data> <media_type>image/png</media_type> </icon> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'IconService:%s' % self._path class IconsService(Service): """ A service to manage icons. """ def __init__(self, connection, path): super(IconsService, self).__init__(connection, path) self._icon_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Get a list of icons. [source] ---- GET /ovirt-engine/api/icons ---- You will get a XML response which is similar to this one: [source,xml] ---- <icons> <icon id="123"> <data>...</data> <media_type>image/png</media_type> </icon> ... </icons> ---- The order of the returned list of icons isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of icons to return. If not specified all the icons are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def icon_service(self, id): """ Reference to the service that manages an specific icon. """ Service._check_types([ ('id', id, str), ]) return IconService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.icon_service(path) return self.icon_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'IconsService:%s' % self._path class ImageService(Service): """ """ def __init__(self, connection, path): super(ImageService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_( self, async_=None, cluster=None, disk=None, import_as_template=None, storage_domain=None, template=None, headers=None, query=None, wait=True, **kwargs ): """ Imports an image. If the `import_as_template` parameter is `true` then the image will be imported as a template, otherwise it will be imported as a disk. When imported as a template, the name of the template can be specified by the optional `template.name` parameter. If that parameter is not specified, then the name of the template will be automatically assigned by the engine as `GlanceTemplate-x` (where `x` will be seven random hexadecimal characters). When imported as a disk, the name of the disk can be specified by the optional `disk.name` parameter. If that parameter is not specified, then the name of the disk will be automatically assigned by the engine as `GlanceDisk-x` (where `x` will be the seven hexadecimal characters of the image identifier). It is recommended to always explicitly specify the template or disk name, to avoid these automatic names generated by the engine. This method supports the following parameters: `cluster`:: The cluster to which the image should be imported if the `import_as_template` parameter is set to `true`. `disk`:: The disk to import. `import_as_template`:: Specifies if a template should be created from the imported disk. `template`:: The name of the template being created if the `import_as_template` parameter is set to `true`. `storage_domain`:: The storage domain to which the disk should be imported. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('disk', disk, types.Disk), ('import_as_template', import_as_template, bool), ('storage_domain', storage_domain, types.StorageDomain), ('template', template, types.Template), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, cluster=cluster, disk=disk, import_as_template=import_as_template, storage_domain=storage_domain, template=template, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ImageService:%s' % self._path class ImageTransferService(Service): """ This service provides a mechanism to control an image transfer. The client will have to create a transfer by using <<services/image_transfers/methods/add, add>> of the <<services/image_transfers>> service, stating the image to transfer data to/from. After doing that, the transfer is managed by this service. *Using oVirt's Python's SDK:* Uploading a `disk` with id `123` (on a random host in the data center): [source,python] ---- transfers_service = system_service.image_transfers_service() transfer = transfers_service.add( types.ImageTransfer( disk=types.Disk( id='123' ) ) ) ---- Uploading a `disk` with id `123` on `host` id `456`: [source,python] ---- transfers_service = system_service.image_transfers_service() transfer = transfers_service.add( types.ImageTransfer( disk=types.Disk( id='123' ), host=types.Host( id='456' ) ) ) ---- If the user wishes to download a disk rather than upload, he/she should specify `download` as the <<types/image_transfer_direction, direction>> attribute of the transfer. This will grant a read permission from the image, instead of a write permission. E.g: [source,python] ---- transfers_service = system_service.image_transfers_service() transfer = transfers_service.add( types.ImageTransfer( disk=types.Disk( id='123' ), direction=types.ImageTransferDirection.DOWNLOAD ) ) ---- Transfers have phases, which govern the flow of the upload/download. A client implementing such a flow should poll/check the transfer's phase and act accordingly. All the possible phases can be found in <<types/image_transfer_phase, ImageTransferPhase>>. After adding a new transfer, its phase will be <<types/image_transfer_phase, initializing>>. The client will have to poll on the transfer's phase until it changes. When the phase becomes <<types/image_transfer_phase, transferring>>, the session is ready to start the transfer. For example: [source,python] ---- transfer_service = transfers_service.image_transfer_service(transfer.id) while transfer.phase == types.ImageTransferPhase.INITIALIZING: time.sleep(3) transfer = transfer_service.get() ---- At that stage, if the transfer's phase is <<types/image_transfer_phase, paused_system>>, then the session was not successfully established. One possible reason for that is that the ovirt-imageio-daemon is not running in the host that was selected for transfer. The transfer can be resumed by calling <<services/image_transfer/methods/resume, resume>> of the service that manages it. If the session was successfully established - the returned transfer entity will contain the <<types/image_transfer, transfer_url>> and <<types/image_transfer, proxy_url>> attributes, which the client needs to use in order to transfer the required data. The client can choose whatever technique and tool for sending the HTTPS request with the image's data. - `transfer_url` is the address of an imageio server running on one of the hypervisors. - `proxy_url` is the address of an imageio proxy server that can be used if you cannot access transfer_url. To transfer the image, it is recommended to use the imageio client python library. [source,python] ---- from ovirt_imageio import client # Upload qcow2 image to virtual disk: client.upload("disk.qcow2", transfer.transfer_url) # Download virtual disk to qcow2 image: client.download(transfer.transfer_url, "disk.qcow2") ---- You can also upload and download using imageio REST API. For more info on this, see imageio API documentation: http://ovirt.github.io/ovirt-imageio/images.html When finishing the transfer, the user should call <<services/image_transfer/methods/finalize, finalize>>. This will make the final adjustments and verifications for finishing the transfer process. For example: [source,python] ---- transfer_service.finalize() ---- In case of an error, the transfer's phase will be changed to <<types/image_transfer_phase, finished_failure>>, and the disk's status will be changed to `Illegal`. Otherwise it will be changed to <<types/image_transfer_phase, finished_success>>, and the disk will be ready to be used. In both cases, the transfer entity will be removed shortly after. *Using HTTP and cURL calls:* - For upload, create a new disk first: * Specify 'initial_size' and 'provisioned_size' in bytes. * 'initial_size' must be bigger or the same as the size of the uploaded data. [source] ---- POST /ovirt-engine/api/disks ---- With a request body as follows: [source,xml] ---- <disk> <storage_domains> <storage_domain id="123"/> </storage_domains> <alias>mydisk</alias> <initial_size>1073741824</initial_size> <provisioned_size>1073741824</provisioned_size> <format>raw</format> </disk> ---- - Create a new image transfer for downloading/uploading a `disk` with id `456`: [source] ---- POST /ovirt-engine/api/imagetransfers ---- With a request body as follows: [source,xml] ---- <image_transfer> <disk id="456"/> <direction>upload|download</direction> </image_transfer> ---- Will respond: [source,xml] ---- <image_transfer id="123"> <direction>download|upload</direction> <phase>initializing|transferring</phase> <proxy_url>https://proxy_fqdn:54323/images/41c732d4-2210-4e7b-9e5c-4e2805baadbb</proxy_url> <transfer_url>https://daemon_fqdn:54322/images/41c732d4-2210-4e7b-9e5c-4e2805baadbb</transfer_url> ... </image_transfer> ---- Note: If the phase is 'initializing', poll the `image_transfer` till its phase changes to 'transferring'. - Use the 'transfer_url' or 'proxy_url' to invoke a curl command: - use 'transfer_url' for transferring directly from/to ovirt-imageio-daemon, or, use 'proxy_url' for transferring from/to ovirt-imageio-proxy. Note: using the proxy would mitigate scenarios where there's no direct connectivity to the daemon machine, e.g. vdsm machines are on a different network than the engine. -- Download: [source,shell] ---- $ curl --cacert /etc/pki/ovirt-engine/ca.pem https://daemon_fqdn:54322/images/41c732d4-2210-4e7b-9e5c-4e2805baadbb -o <output_file> ---- -- Upload: [source,shell] ---- $ curl --cacert /etc/pki/ovirt-engine/ca.pem --upload-file <file_to_upload> -X PUT https://daemon_fqdn:54322/images/41c732d4-2210-4e7b-9e5c-4e2805baadbb ---- - Finalize the image transfer by invoking the action: [source] ---- POST /ovirt-engine/api/imagetransfers/123/finalize ---- With a request body as follows: [source,xml] ---- <action /> ---- """ def __init__(self, connection, path): super(ImageTransferService, self).__init__(connection, path) def cancel( self, headers=None, query=None, wait=True, **kwargs ): """ Cancel the image transfer session. This terminates the transfer operation and removes the partial image. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'cancel', None, headers, query, wait) def extend( self, headers=None, query=None, wait=True, **kwargs ): """ Extend the image transfer session. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'extend', None, headers, query, wait) def finalize( self, headers=None, query=None, wait=True, **kwargs ): """ After finishing to transfer the data, finalize the transfer. This will make sure that the data being transferred is valid and fits the image entity that was targeted in the transfer. Specifically, will verify that if the image entity is a QCOW disk, the data uploaded is indeed a QCOW file, and that the image doesn't have a backing file. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'finalize', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get the image transfer entity. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def pause( self, headers=None, query=None, wait=True, **kwargs ): """ Pause the image transfer session. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'pause', None, headers, query, wait) def resume( self, headers=None, query=None, wait=True, **kwargs ): """ Resume the image transfer session. The client will need to poll the transfer's phase until it is different than `resuming`. For example: [source,python] ---- transfer_service = transfers_service.image_transfer_service(transfer.id) transfer_service.resume() transfer = transfer_service.get() while transfer.phase == types.ImageTransferPhase.RESUMING: time.sleep(1) transfer = transfer_service.get() ---- """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'resume', None, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ImageTransferService:%s' % self._path class ImageTransfersService(Service): """ This service manages image transfers, for performing Image I/O API in {product-name}. Please refer to <<services/image_transfer, image transfer>> for further documentation. """ def __init__(self, connection, path): super(ImageTransfersService, self).__init__(connection, path) self._image_transfer_service = None def add( self, image_transfer, headers=None, query=None, wait=True, **kwargs ): """ Add a new image transfer. An image, disk or disk snapshot needs to be specified in order to make a new transfer. IMPORTANT: The `image` attribute is deprecated since version 4.2 of the engine. Use the `disk` or `snapshot` attributes instead. *Creating a new image transfer for downloading or uploading a `disk`:* To create an image transfer to download or upload a disk with id `123`, send the following request: [source] ---- POST /ovirt-engine/api/imagetransfers ---- With a request body like this: [source,xml] ---- <image_transfer> <disk id="123"/> <direction>upload|download</direction> </image_transfer> ---- *Creating a new image transfer for downloading or uploading a `disk_snapshot`:* To create an image transfer to download or upload a `disk_snapshot` with id `456`, send the following request: [source] ---- POST /ovirt-engine/api/imagetransfers ---- With a request body like this: [source,xml] ---- <image_transfer> <snapshot id="456"/> <direction>download|upload</direction> </image_transfer> ---- This method supports the following parameters: `image_transfer`:: The image transfer to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('image_transfer', image_transfer, types.ImageTransfer), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(image_transfer, headers, query, wait) def add_for_disk( self, image_transfer, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `image_transfer`:: The image transfer to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('image_transfer', image_transfer, types.ImageTransfer), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(image_transfer, headers, query, wait) def add_for_image( self, image_transfer, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `image_transfer`:: The image transfer to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('image_transfer', image_transfer, types.ImageTransfer), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(image_transfer, headers, query, wait) def add_for_snapshot( self, image_transfer, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `image_transfer`:: The image transfer to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('image_transfer', image_transfer, types.ImageTransfer), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(image_transfer, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the list of image transfers that are currently being performed. The order of the returned list of image transfers is not guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def image_transfer_service(self, id): """ Returns a reference to the service that manages an specific image transfer. """ Service._check_types([ ('id', id, str), ]) return ImageTransferService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.image_transfer_service(path) return self.image_transfer_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ImageTransfersService:%s' % self._path class ImagesService(Service): """ Manages the set of images available in an storage domain or in an OpenStack image provider. """ def __init__(self, connection, path): super(ImagesService, self).__init__(connection, path) self._image_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of images available in the storage domain or provider. The order of the returned list of images isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of images to return. If not specified all the images are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def image_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ImageService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.image_service(path) return self.image_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ImagesService:%s' % self._path class InstanceTypeService(Service): """ """ def __init__(self, connection, path): super(InstanceTypeService, self).__init__(connection, path) self._graphics_consoles_service = None self._nics_service = None self._watchdogs_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get a specific instance type and it's attributes. [source] ---- GET /ovirt-engine/api/instancetypes/123 ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a specific instance type from the system. If a virtual machine was created using an instance type X after removal of the instance type the virtual machine's instance type will be set to `custom`. [source] ---- DELETE /ovirt-engine/api/instancetypes/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, instance_type, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update a specific instance type and it's attributes. All the attributes are editable after creation. If a virtual machine was created using an instance type X and some configuration in instance type X was updated, the virtual machine's configuration will be updated automatically by the engine. [source] ---- PUT /ovirt-engine/api/instancetypes/123 ---- For example, to update the memory of instance type `123` to 1 GiB and set the cpu topology to 2 sockets and 1 core, send a request like this: [source, xml] ---- <instance_type> <memory>1073741824</memory> <cpu> <topology> <cores>1</cores> <sockets>2</sockets> <threads>1</threads> </topology> </cpu> </instance_type> ---- """ # Check the types of the parameters: Service._check_types([ ('instance_type', instance_type, types.InstanceType), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(instance_type, headers, query, wait) def graphics_consoles_service(self): """ Reference to the service that manages the graphic consoles that are attached to this instance type. """ return InstanceTypeGraphicsConsolesService(self._connection, '%s/graphicsconsoles' % self._path) def nics_service(self): """ Reference to the service that manages the NICs that are attached to this instance type. """ return InstanceTypeNicsService(self._connection, '%s/nics' % self._path) def watchdogs_service(self): """ Reference to the service that manages the watchdogs that are attached to this instance type. """ return InstanceTypeWatchdogsService(self._connection, '%s/watchdogs' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'graphicsconsoles': return self.graphics_consoles_service() if path.startswith('graphicsconsoles/'): return self.graphics_consoles_service().service(path[17:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) if path == 'watchdogs': return self.watchdogs_service() if path.startswith('watchdogs/'): return self.watchdogs_service().service(path[10:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'InstanceTypeService:%s' % self._path class InstanceTypeGraphicsConsoleService(Service): """ """ def __init__(self, connection, path): super(InstanceTypeGraphicsConsoleService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets graphics console configuration of the instance type. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the graphics console from the instance type. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'InstanceTypeGraphicsConsoleService:%s' % self._path class InstanceTypeGraphicsConsolesService(Service): """ """ def __init__(self, connection, path): super(InstanceTypeGraphicsConsolesService, self).__init__(connection, path) self._console_service = None def add( self, console, headers=None, query=None, wait=True, **kwargs ): """ Add new graphics console to the instance type. """ # Check the types of the parameters: Service._check_types([ ('console', console, types.GraphicsConsole), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(console, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured graphics consoles of the instance type. The order of the returned list of graphics consoles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of consoles to return. If not specified all the consoles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def console_service(self, id): """ Returns a reference to the service that manages a specific instance type graphics console. """ Service._check_types([ ('id', id, str), ]) return InstanceTypeGraphicsConsoleService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.console_service(path) return self.console_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'InstanceTypeGraphicsConsolesService:%s' % self._path class InstanceTypeNicService(Service): """ """ def __init__(self, connection, path): super(InstanceTypeNicService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets network interface configuration of the instance type. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the network interface from the instance type. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, nic, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the network interface configuration of the instance type. """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(nic, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'InstanceTypeNicService:%s' % self._path class InstanceTypeNicsService(Service): """ """ def __init__(self, connection, path): super(InstanceTypeNicsService, self).__init__(connection, path) self._nic_service = None def add( self, nic, headers=None, query=None, wait=True, **kwargs ): """ Add new network interface to the instance type. """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(nic, headers, query, wait) def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured network interface of the instance type. The order of the returned list of network interfaces isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `search`:: A query string used to restrict the returned templates. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def nic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return InstanceTypeNicService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'InstanceTypeNicsService:%s' % self._path class InstanceTypeWatchdogService(Service): """ """ def __init__(self, connection, path): super(InstanceTypeWatchdogService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets watchdog configuration of the instance type. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove a watchdog from the instance type. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, watchdog, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the watchdog configuration of the instance type. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(watchdog, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'InstanceTypeWatchdogService:%s' % self._path class InstanceTypeWatchdogsService(Service): """ """ def __init__(self, connection, path): super(InstanceTypeWatchdogsService, self).__init__(connection, path) self._watchdog_service = None def add( self, watchdog, headers=None, query=None, wait=True, **kwargs ): """ Add new watchdog to the instance type. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(watchdog, headers, query, wait) def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured watchdogs of the instance type. The order of the returned list of watchdogs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of watchdogs to return. If not specified all the watchdogs are returned. `search`:: A query string used to restrict the returned templates. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def watchdog_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return InstanceTypeWatchdogService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.watchdog_service(path) return self.watchdog_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'InstanceTypeWatchdogsService:%s' % self._path class InstanceTypesService(Service): """ """ def __init__(self, connection, path): super(InstanceTypesService, self).__init__(connection, path) self._instance_type_service = None def add( self, instance_type, headers=None, query=None, wait=True, **kwargs ): """ Creates a new instance type. This requires only a name attribute and can include all hardware configurations of the virtual machine. [source] ---- POST /ovirt-engine/api/instancetypes ---- With a request body like this: [source,xml] ---- <instance_type> <name>myinstancetype</name> </template> ---- Creating an instance type with all hardware configurations with a request body like this: [source,xml] ---- <instance_type> <name>myinstancetype</name> <console> <enabled>true</enabled> </console> <cpu> <topology> <cores>2</cores> <sockets>2</sockets> <threads>1</threads> </topology> </cpu> <custom_cpu_model>AMD Opteron_G2</custom_cpu_model> <custom_emulated_machine>q35</custom_emulated_machine> <display> <monitors>1</monitors> <single_qxl_pci>true</single_qxl_pci> <smartcard_enabled>true</smartcard_enabled> <type>spice</type> </display> <high_availability> <enabled>true</enabled> <priority>1</priority> </high_availability> <io> <threads>2</threads> </io> <memory>4294967296</memory> <memory_policy> <ballooning>true</ballooning> <guaranteed>268435456</guaranteed> </memory_policy> <migration> <auto_converge>inherit</auto_converge> <compressed>inherit</compressed> <policy id="00000000-0000-0000-0000-000000000000"/> </migration> <migration_downtime>2</migration_downtime> <os> <boot> <devices> <device>hd</device> </devices> </boot> </os> <rng_device> <rate> <bytes>200</bytes> <period>2</period> </rate> <source>urandom</source> </rng_device> <soundcard_enabled>true</soundcard_enabled> <usb> <enabled>true</enabled> <type>native</type> </usb> <virtio_scsi> <enabled>true</enabled> </virtio_scsi> </instance_type> ---- """ # Check the types of the parameters: Service._check_types([ ('instance_type', instance_type, types.InstanceType), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(instance_type, headers, query, wait) def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all existing instance types in the system. The order of the returned list of instance types isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of instance types to return. If not specified all the instance types are returned. `search`:: A query string used to restrict the returned templates. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def instance_type_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return InstanceTypeService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.instance_type_service(path) return self.instance_type_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'InstanceTypesService:%s' % self._path class IscsiBondService(Service): """ """ def __init__(self, connection, path): super(IscsiBondService, self).__init__(connection, path) self._networks_service = None self._storage_server_connections_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes of an existing iSCSI bond. For example, to remove the iSCSI bond `456` send a request like this: [source] ---- DELETE /ovirt-engine/api/datacenters/123/iscsibonds/456 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, bond, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates an iSCSI bond. Updating of an iSCSI bond can be done on the `name` and the `description` attributes only. For example, to update the iSCSI bond `456` of data center `123`, send a request like this: [source] ---- PUT /ovirt-engine/api/datacenters/123/iscsibonds/1234 ---- The request body should look like this: [source,xml] ---- <iscsi_bond> <name>mybond</name> <description>My iSCSI bond</description> </iscsi_bond> ---- This method supports the following parameters: `bond`:: The iSCSI bond to update. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bond', bond, types.IscsiBond), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(bond, headers, query, wait) def networks_service(self): """ """ return NetworksService(self._connection, '%s/networks' % self._path) def storage_server_connections_service(self): """ """ return StorageServerConnectionsService(self._connection, '%s/storageserverconnections' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) if path == 'storageserverconnections': return self.storage_server_connections_service() if path.startswith('storageserverconnections/'): return self.storage_server_connections_service().service(path[25:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'IscsiBondService:%s' % self._path class IscsiBondsService(Service): """ """ def __init__(self, connection, path): super(IscsiBondsService, self).__init__(connection, path) self._iscsi_bond_service = None def add( self, bond, headers=None, query=None, wait=True, **kwargs ): """ Create a new iSCSI bond on a data center. For example, to create a new iSCSI bond on data center `123` using storage connections `456` and `789`, send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/iscsibonds ---- The request body should look like this: [source,xml] ---- <iscsi_bond> <name>mybond</name> <storage_connections> <storage_connection id="456"/> <storage_connection id="789"/> </storage_connections> <networks> <network id="abc"/> </networks> </iscsi_bond> ---- """ # Check the types of the parameters: Service._check_types([ ('bond', bond, types.IscsiBond), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(bond, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of iSCSI bonds configured in the data center. The order of the returned list of iSCSI bonds isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of bonds to return. If not specified all the bonds are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def iscsi_bond_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return IscsiBondService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.iscsi_bond_service(path) return self.iscsi_bond_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'IscsiBondsService:%s' % self._path class JobService(Service): """ A service to manage a job. """ def __init__(self, connection, path): super(JobService, self).__init__(connection, path) self._steps_service = None def clear( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Set an external job execution to be cleared by the system. For example, to set a job with identifier `123` send the following request: [source] ---- POST /ovirt-engine/api/jobs/clear ---- With the following request body: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'clear', None, headers, query, wait) def end( self, async_=None, force=None, succeeded=None, headers=None, query=None, wait=True, **kwargs ): """ Marks an external job execution as ended. For example, to terminate a job with identifier `123` send the following request: [source] ---- POST /ovirt-engine/api/jobs/end ---- With the following request body: [source,xml] ---- <action> <force>true</force> <status>finished</status> </action> ---- This method supports the following parameters: `force`:: Indicates if the job should be forcibly terminated. `succeeded`:: Indicates if the job should be marked as successfully finished or as failed. This parameter is optional, and the default value is `true`. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('succeeded', succeeded, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, succeeded=succeeded, ) # Send the request and wait for the response: return self._internal_action(action, 'end', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a job. [source] ---- GET /ovirt-engine/api/jobs/123 ---- You will receive response in XML like this one: [source,xml] ---- <job href="/ovirt-engine/api/jobs/123" id="123"> <actions> <link href="/ovirt-engine/api/jobs/123/clear" rel="clear"/> <link href="/ovirt-engine/api/jobs/123/end" rel="end"/> </actions> <description>Adding Disk</description> <link href="/ovirt-engine/api/jobs/123/steps" rel="steps"/> <auto_cleared>true</auto_cleared> <end_time>2016-12-12T23:07:29.758+02:00</end_time> <external>false</external> <last_updated>2016-12-12T23:07:29.758+02:00</last_updated> <start_time>2016-12-12T23:07:26.593+02:00</start_time> <status>failed</status> <owner href="/ovirt-engine/api/users/456" id="456"/> </job> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def steps_service(self): """ List all the steps of the job. The order of the returned list of steps isn't guaranteed. """ return StepsService(self._connection, '%s/steps' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'steps': return self.steps_service() if path.startswith('steps/'): return self.steps_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'JobService:%s' % self._path class JobsService(Service): """ A service to manage jobs. """ def __init__(self, connection, path): super(JobsService, self).__init__(connection, path) self._job_service = None def add( self, job, headers=None, query=None, wait=True, **kwargs ): """ Add an external job. For example, to add a job with the following request: [source] ---- POST /ovirt-engine/api/jobs ---- With the following request body: [source,xml] ---- <job> <description>Doing some work</description> <auto_cleared>true</auto_cleared> </job> ---- The response should look like: [source,xml] ---- <job href="/ovirt-engine/api/jobs/123" id="123"> <actions> <link href="/ovirt-engine/api/jobs/123/clear" rel="clear"/> <link href="/ovirt-engine/api/jobs/123/end" rel="end"/> </actions> <description>Doing some work</description> <link href="/ovirt-engine/api/jobs/123/steps" rel="steps"/> <auto_cleared>true</auto_cleared> <external>true</external> <last_updated>2016-12-13T02:15:42.130+02:00</last_updated> <start_time>2016-12-13T02:15:42.130+02:00</start_time> <status>started</status> <owner href="/ovirt-engine/api/users/456" id="456"/> </job> ---- This method supports the following parameters: `job`:: Job that will be added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('job', job, types.Job), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(job, headers, query, wait) def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representation of the jobs. [source] ---- GET /ovirt-engine/api/jobs ---- You will receive response in XML like this one: [source,xml] ---- <jobs> <job href="/ovirt-engine/api/jobs/123" id="123"> <actions> <link href="/ovirt-engine/api/jobs/123/clear" rel="clear"/> <link href="/ovirt-engine/api/jobs/123/end" rel="end"/> </actions> <description>Adding Disk</description> <link href="/ovirt-engine/api/jobs/123/steps" rel="steps"/> <auto_cleared>true</auto_cleared> <end_time>2016-12-12T23:07:29.758+02:00</end_time> <external>false</external> <last_updated>2016-12-12T23:07:29.758+02:00</last_updated> <start_time>2016-12-12T23:07:26.593+02:00</start_time> <status>failed</status> <owner href="/ovirt-engine/api/users/456" id="456"/> </job> ... </jobs> ---- The order of the returned list of jobs isn't guaranteed. This method supports the following parameters: `search`:: A query string used to restrict the returned jobs. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `max`:: Sets the maximum number of jobs to return. If not specified all the jobs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def job_service(self, id): """ Reference to the job service. """ Service._check_types([ ('id', id, str), ]) return JobService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.job_service(path) return self.job_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'JobsService:%s' % self._path class KatelloErrataService(Service): """ A service to manage Katello errata. The information is retrieved from Katello. """ def __init__(self, connection, path): super(KatelloErrataService, self).__init__(connection, path) self._katello_erratum_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representation of the Katello errata. [source] ---- GET /ovirt-engine/api/katelloerrata ---- You will receive response in XML like this one: [source,xml] ---- <katello_errata> <katello_erratum href="/ovirt-engine/api/katelloerrata/123" id="123"> <name>RHBA-2013:XYZ</name> <description>The description of the erratum</description> <title>some bug fix update</title> <type>bugfix</type> <issued>2013-11-20T02:00:00.000+02:00</issued> <solution>Few guidelines regarding the solution</solution> <summary>Updated packages that fix one bug are now available for XYZ</summary> <packages> <package> <name>libipa_hbac-1.9.2-82.11.el6_4.i686</name> </package> ... </packages> </katello_erratum> ... </katello_errata> ---- The order of the returned list of erratum isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of errata to return. If not specified all the errata are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def katello_erratum_service(self, id): """ Reference to the Katello erratum service. Use this service to view the erratum by its id. """ Service._check_types([ ('id', id, str), ]) return KatelloErratumService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.katello_erratum_service(path) return self.katello_erratum_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'KatelloErrataService:%s' % self._path class KatelloErratumService(Service): """ A service to manage a Katello erratum. """ def __init__(self, connection, path): super(KatelloErratumService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a Katello erratum. [source] ---- GET /ovirt-engine/api/katelloerrata/123 ---- You will receive response in XML like this one: [source,xml] ---- <katello_erratum href="/ovirt-engine/api/katelloerrata/123" id="123"> <name>RHBA-2013:XYZ</name> <description>The description of the erratum</description> <title>some bug fix update</title> <type>bugfix</type> <issued>2013-11-20T02:00:00.000+02:00</issued> <solution>Few guidelines regarding the solution</solution> <summary>Updated packages that fix one bug are now available for XYZ</summary> <packages> <package> <name>libipa_hbac-1.9.2-82.11.el6_4.i686</name> </package> ... </packages> </katello_erratum> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'KatelloErratumService:%s' % self._path class LinkLayerDiscoveryProtocolService(Service): """ A service to fetch information elements received by Link Layer Discovery Protocol (LLDP). """ def __init__(self, connection, path): super(LinkLayerDiscoveryProtocolService, self).__init__(connection, path) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Fetches information elements received by LLDP. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'LinkLayerDiscoveryProtocolService:%s' % self._path class MacPoolService(Service): """ """ def __init__(self, connection, path): super(MacPoolService, self).__init__(connection, path) self._permissions_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a MAC address pool. For example, to remove the MAC address pool having id `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/macpools/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, pool, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a MAC address pool. The `name`, `description`, `allow_duplicates`, and `ranges` attributes can be updated. For example, to update the MAC address pool of id `123` send a request like this: [source] ---- PUT /ovirt-engine/api/macpools/123 ---- With a request body like this: [source,xml] ---- <mac_pool> <name>UpdatedMACPool</name> <description>An updated MAC address pool</description> <allow_duplicates>false</allow_duplicates> <ranges> <range> <from>00:1A:4A:16:01:51</from> <to>00:1A:4A:16:01:e6</to> </range> <range> <from>02:1A:4A:01:00:00</from> <to>02:1A:4A:FF:FF:FF</to> </range> </ranges> </mac_pool> ---- """ # Check the types of the parameters: Service._check_types([ ('pool', pool, types.MacPool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(pool, headers, query, wait) def permissions_service(self): """ Returns a reference to the service that manages the permissions that are associated with the MacPool. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'MacPoolService:%s' % self._path class MacPoolsService(Service): """ """ def __init__(self, connection, path): super(MacPoolsService, self).__init__(connection, path) self._mac_pool_service = None def add( self, pool, headers=None, query=None, wait=True, **kwargs ): """ Creates a new MAC address pool. Creation of a MAC address pool requires values for the `name` and `ranges` attributes. For example, to create MAC address pool send a request like this: [source] ---- POST /ovirt-engine/api/macpools ---- With a request body like this: [source,xml] ---- <mac_pool> <name>MACPool</name> <description>A MAC address pool</description> <allow_duplicates>true</allow_duplicates> <default_pool>false</default_pool> <ranges> <range> <from>00:1A:4A:16:01:51</from> <to>00:1A:4A:16:01:e6</to> </range> </ranges> </mac_pool> ---- """ # Check the types of the parameters: Service._check_types([ ('pool', pool, types.MacPool), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(pool, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Return the list of MAC address pools of the system. The returned list of MAC address pools isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of pools to return. If not specified all the pools are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def mac_pool_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return MacPoolService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.mac_pool_service(path) return self.mac_pool_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'MacPoolsService:%s' % self._path class MeasurableService(Service): """ """ def __init__(self, connection, path): super(MeasurableService, self).__init__(connection, path) self._statistics_service = None def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'MeasurableService:%s' % self._path class MoveableService(Service): """ """ def __init__(self, connection, path): super(MoveableService, self).__init__(connection, path) def move( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the move should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'MoveableService:%s' % self._path class NetworkService(Service): """ A service managing a network """ def __init__(self, connection, path): super(NetworkService, self).__init__(connection, path) self._network_labels_service = None self._permissions_service = None self._vnic_profiles_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets a logical network. For example: [source] ---- GET /ovirt-engine/api/networks/123 ---- Will respond: [source,xml] ---- <network href="/ovirt-engine/api/networks/123" id="123"> <name>ovirtmgmt</name> <description>Default Management Network</description> <link href="/ovirt-engine/api/networks/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/networks/123/vnicprofiles" rel="vnicprofiles"/> <link href="/ovirt-engine/api/networks/123/networklabels" rel="networklabels"/> <mtu>0</mtu> <stp>false</stp> <usages> <usage>vm</usage> </usages> <data_center href="/ovirt-engine/api/datacenters/456" id="456"/> </network> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a logical network, or the association of a logical network to a data center. For example, to remove the logical network `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/networks/123 ---- Each network is bound exactly to one data center. So if we disassociate network with data center it has the same result as if we would just remove that network. However it might be more specific to say we're removing network `456` of data center `123`. For example, to remove the association of network `456` to data center `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/datacenters/123/networks/456 ---- NOTE: To remove an external logical network, the network has to be removed directly from its provider by https://developer.openstack.org/api-ref/network[OpenStack Networking API]. The entity representing the external network inside {product-name} is removed automatically, if <<types/open_stack_network_provider/attributes/auto_sync,`auto_sync`>> is enabled for the provider, otherwise the entity has to be removed using this method. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, network, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a logical network. The `name`, `description`, `ip`, `vlan`, `stp` and `display` attributes can be updated. For example, to update the description of the logical network `123` send a request like this: [source] ---- PUT /ovirt-engine/api/networks/123 ---- With a request body like this: [source,xml] ---- <network> <description>My updated description</description> </network> ---- The maximum transmission unit of a network is set using a PUT request to specify the integer value of the `mtu` attribute. For example, to set the maximum transmission unit send a request like this: [source] ---- PUT /ovirt-engine/api/datacenters/123/networks/456 ---- With a request body like this: [source,xml] ---- <network> <mtu>1500</mtu> </network> ---- NOTE: Updating external networks is not propagated to the provider. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(network, headers, query, wait) def network_labels_service(self): """ Reference to the service that manages the network labels assigned to this network. """ return NetworkLabelsService(self._connection, '%s/networklabels' % self._path) def permissions_service(self): """ Reference to the service that manages the permissions assigned to this network. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def vnic_profiles_service(self): """ Reference to the service that manages the vNIC profiles assigned to this network. """ return AssignedVnicProfilesService(self._connection, '%s/vnicprofiles' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'networklabels': return self.network_labels_service() if path.startswith('networklabels/'): return self.network_labels_service().service(path[14:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'vnicprofiles': return self.vnic_profiles_service() if path.startswith('vnicprofiles/'): return self.vnic_profiles_service().service(path[13:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'NetworkService:%s' % self._path class NetworkAttachmentService(Service): """ """ def __init__(self, connection, path): super(NetworkAttachmentService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, attachment, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified network attachment on the host. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.NetworkAttachment), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(attachment, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'NetworkAttachmentService:%s' % self._path class NetworkAttachmentsService(Service): """ Manages the set of network attachments of a host or host NIC. """ def __init__(self, connection, path): super(NetworkAttachmentsService, self).__init__(connection, path) self._attachment_service = None def add( self, attachment, headers=None, query=None, wait=True, **kwargs ): """ Add a new network attachment to the network interface. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.NetworkAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(attachment, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of network attachments of the host or host NIC. The order of the returned list of network attachments isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of attachments to return. If not specified all the attachments are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def attachment_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return NetworkAttachmentService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.attachment_service(path) return self.attachment_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'NetworkAttachmentsService:%s' % self._path class NetworkFilterService(Service): """ Manages a network filter. [source,xml] ---- <network_filter id="00000019-0019-0019-0019-00000000026b"> <name>example-network-filter-b</name> <version> <major>4</major> <minor>0</minor> <build>-1</build> <revision>-1</revision> </version> </network_filter> ---- Please note that version is referring to the minimal support version for the specific filter. """ def __init__(self, connection, path): super(NetworkFilterService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a representation of the network filter. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'NetworkFilterService:%s' % self._path class NetworkFiltersService(Service): """ Represents a readonly network filters sub-collection. The network filter enables to filter packets send to/from the VM's nic according to defined rules. For more information please refer to <<services/network_filter,NetworkFilter>> service documentation Network filters are supported in different versions, starting from version 3.0. A network filter is defined for each vnic profile. A vnic profile is defined for a specific network. A network can be assigned to several different clusters. In the future, each network will be defined in cluster level. Currently, each network is being defined at data center level. Potential network filters for each network are determined by the network's data center compatibility version V. V must be >= the network filter version in order to configure this network filter for a specific network. Please note, that if a network is assigned to cluster with a version supporting a network filter, the filter may not be available due to the data center version being smaller then the network filter's version. Example of listing all of the supported network filters for a specific cluster: [source] ---- GET http://localhost:8080/ovirt-engine/api/clusters/{cluster:id}/networkfilters ---- Output: [source,xml] ---- <network_filters> <network_filter id="00000019-0019-0019-0019-00000000026c"> <name>example-network-filter-a</name> <version> <major>4</major> <minor>0</minor> <build>-1</build> <revision>-1</revision> </version> </network_filter> <network_filter id="00000019-0019-0019-0019-00000000026b"> <name>example-network-filter-b</name> <version> <major>4</major> <minor>0</minor> <build>-1</build> <revision>-1</revision> </version> </network_filter> <network_filter id="00000019-0019-0019-0019-00000000026a"> <name>example-network-filter-a</name> <version> <major>3</major> <minor>0</minor> <build>-1</build> <revision>-1</revision> </version> </network_filter> </network_filters> ---- """ def __init__(self, connection, path): super(NetworkFiltersService, self).__init__(connection, path) self._network_filter_service = None def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representations of the network filters. The order of the returned list of network filters isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def network_filter_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return NetworkFilterService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_filter_service(path) return self.network_filter_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'NetworkFiltersService:%s' % self._path class NetworkLabelService(Service): """ """ def __init__(self, connection, path): super(NetworkLabelService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a label from a logical network. For example, to remove the label `exemplary` from a logical network having id `123` send the following request: [source] ---- DELETE /ovirt-engine/api/networks/123/networklabels/exemplary ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'NetworkLabelService:%s' % self._path class NetworkLabelsService(Service): """ Manages the ser of labels attached to a network or to a host NIC. """ def __init__(self, connection, path): super(NetworkLabelsService, self).__init__(connection, path) self._label_service = None def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Attaches label to logical network. You can attach labels to a logical network to automate the association of that logical network with physical host network interfaces to which the same label has been attached. For example, to attach the label `mylabel` to a logical network having id `123` send a request like this: [source] ---- POST /ovirt-engine/api/networks/123/networklabels ---- With a request body like this: [source,xml] ---- <network_label id="mylabel"/> ---- """ # Check the types of the parameters: Service._check_types([ ('label', label, types.NetworkLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of labels attached to the network or host NIC. The order of the returned list of labels isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of labels to return. If not specified all the labels are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def label_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return NetworkLabelService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'NetworkLabelsService:%s' % self._path class NetworksService(Service): """ Manages logical networks. The engine creates a default `ovirtmgmt` network on installation. This network acts as the management network for access to hypervisor hosts. This network is associated with the `Default` cluster and is a member of the `Default` data center. """ def __init__(self, connection, path): super(NetworksService, self).__init__(connection, path) self._network_service = None def add( self, network, headers=None, query=None, wait=True, **kwargs ): """ Creates a new logical network, or associates an existing network with a data center. Creation of a new network requires the `name` and `data_center` elements. For example, to create a network named `mynetwork` for data center `123` send a request like this: [source] ---- POST /ovirt-engine/api/networks ---- With a request body like this: [source,xml] ---- <network> <name>mynetwork</name> <data_center id="123"/> </network> ---- To associate the existing network `456` with the data center `123` send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/networks ---- With a request body like this: [source,xml] ---- <network> <name>ovirtmgmt</name> </network> ---- To create a network named `exnetwork` on top of an external _OpenStack_ network provider `456` send a request like this: [source] ---- POST /ovirt-engine/api/networks ---- [source,xml] ---- <network> <name>exnetwork</name> <external_provider id="456"/> <data_center id="123"/> </network> ---- """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(network, headers, query, wait) def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ List logical networks. For example: [source] ---- GET /ovirt-engine/api/networks ---- Will respond: [source,xml] ---- <networks> <network href="/ovirt-engine/api/networks/123" id="123"> <name>ovirtmgmt</name> <description>Default Management Network</description> <link href="/ovirt-engine/api/networks/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/networks/123/vnicprofiles" rel="vnicprofiles"/> <link href="/ovirt-engine/api/networks/123/networklabels" rel="networklabels"/> <mtu>0</mtu> <stp>false</stp> <usages> <usage>vm</usage> </usages> <data_center href="/ovirt-engine/api/datacenters/456" id="456"/> </network> ... </networks> ---- The order of the returned list of networks is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `search`:: A query string used to restrict the returned networks. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def network_service(self, id): """ Reference to the service that manages a specific network. """ Service._check_types([ ('id', id, str), ]) return NetworkService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'NetworksService:%s' % self._path class NicNetworkFilterParameterService(Service): """ This service manages a parameter for a network filter. """ def __init__(self, connection, path): super(NicNetworkFilterParameterService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a representation of the network filter parameter. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes the filter parameter. For example, to remove the filter parameter with id `123` on NIC `456` of virtual machine `789` send a request like this: [source] ---- DELETE /ovirt-engine/api/vms/789/nics/456/networkfilterparameters/123 ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, parameter, headers=None, query=None, wait=True, **kwargs ): """ Updates the network filter parameter. For example, to update the network filter parameter having with with id `123` on NIC `456` of virtual machine `789` send a request like this: [source] ---- PUT /ovirt-engine/api/vms/789/nics/456/networkfilterparameters/123 ---- With a request body like this: [source,xml] ---- <network_filter_parameter> <name>updatedName</name> <value>updatedValue</value> </network_filter_parameter> ---- This method supports the following parameters: `parameter`:: The network filter parameter that is being updated. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('parameter', parameter, types.NetworkFilterParameter), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(parameter, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'NicNetworkFilterParameterService:%s' % self._path class NicNetworkFilterParametersService(Service): """ This service manages a collection of parameters for network filters. """ def __init__(self, connection, path): super(NicNetworkFilterParametersService, self).__init__(connection, path) self._parameter_service = None def add( self, parameter, headers=None, query=None, wait=True, **kwargs ): """ Add a network filter parameter. For example, to add the parameter for the network filter on NIC `456` of virtual machine `789` send a request like this: [source] ---- POST /ovirt-engine/api/vms/789/nics/456/networkfilterparameters ---- With a request body like this: [source,xml] ---- <network_filter_parameter> <name>IP</name> <value>10.0.1.2</value> </network_filter_parameter> ---- This method supports the following parameters: `parameter`:: The network filter parameter that is being added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('parameter', parameter, types.NetworkFilterParameter), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(parameter, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representations of the network filter parameters. The order of the returned list of network filters isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def parameter_service(self, id): """ Reference to the service that manages a specific network filter parameter. """ Service._check_types([ ('id', id, str), ]) return NicNetworkFilterParameterService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.parameter_service(path) return self.parameter_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'NicNetworkFilterParametersService:%s' % self._path class OpenstackImageService(Service): """ """ def __init__(self, connection, path): super(OpenstackImageService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_( self, async_=None, cluster=None, disk=None, import_as_template=None, storage_domain=None, template=None, headers=None, query=None, wait=True, **kwargs ): """ Imports a virtual machine from a Glance image storage domain. For example, to import the image with identifier `456` from the storage domain with identifier `123` send a request like this: [source] ---- POST /ovirt-engine/api/openstackimageproviders/123/images/456/import ---- With a request body like this: [source,xml] ---- <action> <storage_domain> <name>images0</name> </storage_domain> <cluster> <name>images0</name> </cluster> </action> ---- This method supports the following parameters: `import_as_template`:: Indicates whether the image should be imported as a template. `cluster`:: This parameter is mandatory in case of using `import_as_template` and indicates which cluster should be used for import glance image as template. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('disk', disk, types.Disk), ('import_as_template', import_as_template, bool), ('storage_domain', storage_domain, types.StorageDomain), ('template', template, types.Template), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, cluster=cluster, disk=disk, import_as_template=import_as_template, storage_domain=storage_domain, template=template, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackImageService:%s' % self._path class OpenstackImageProviderService(ExternalProviderService): """ """ def __init__(self, connection, path): super(OpenstackImageProviderService, self).__init__(connection, path) self._certificates_service = None self._images_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait) def update( self, provider, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified OpenStack image provider in the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackImageProvider), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(provider, headers, query, wait) def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path) def images_service(self): """ """ return OpenstackImagesService(self._connection, '%s/images' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) if path == 'images': return self.images_service() if path.startswith('images/'): return self.images_service().service(path[7:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackImageProviderService:%s' % self._path class OpenstackImageProvidersService(Service): """ """ def __init__(self, connection, path): super(OpenstackImageProvidersService, self).__init__(connection, path) self._provider_service = None def add( self, provider, headers=None, query=None, wait=True, **kwargs ): """ Add a new OpenStack image provider to the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackImageProvider), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(provider, headers, query, wait) def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of providers. The order of the returned list of providers isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of providers to return. If not specified all the providers are returned. `search`:: A query string used to restrict the returned OpenStack image providers. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def provider_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackImageProviderService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.provider_service(path) return self.provider_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackImageProvidersService:%s' % self._path class OpenstackImagesService(Service): """ """ def __init__(self, connection, path): super(OpenstackImagesService, self).__init__(connection, path) self._image_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the images of a Glance image storage domain. The order of the returned list of images isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of images to return. If not specified all the images are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def image_service(self, id): """ Returns a reference to the service that manages a specific image. """ Service._check_types([ ('id', id, str), ]) return OpenstackImageService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.image_service(path) return self.image_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackImagesService:%s' % self._path class OpenstackNetworkService(Service): """ """ def __init__(self, connection, path): super(OpenstackNetworkService, self).__init__(connection, path) self._subnets_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_( self, async_=None, data_center=None, headers=None, query=None, wait=True, **kwargs ): """ This operation imports an external network into {product-name}. The network will be added to the specified data center. This method supports the following parameters: `data_center`:: The data center into which the network is to be imported. Data center is mandatory, and can be specified using the `id` or `name` attributes. The rest of the attributes will be ignored. NOTE: If <<types/open_stack_network_provider/attributes/auto_sync,`auto_sync`>> is enabled for the provider, the network might be imported automatically. To prevent this, automatic import can be disabled by setting the `auto_sync` to false, and enabling it again after importing the network. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('data_center', data_center, types.DataCenter), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, data_center=data_center, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait) def subnets_service(self): """ """ return OpenstackSubnetsService(self._connection, '%s/subnets' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'subnets': return self.subnets_service() if path.startswith('subnets/'): return self.subnets_service().service(path[8:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackNetworkService:%s' % self._path class OpenstackNetworkProviderService(ExternalProviderService): """ This service manages the OpenStack network provider. """ def __init__(self, connection, path): super(OpenstackNetworkProviderService, self).__init__(connection, path) self._certificates_service = None self._networks_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the representation of the object managed by this service. For example, to get the OpenStack network provider with identifier `1234`, send a request like this: [source] ---- GET /ovirt-engine/api/openstacknetworkproviders/1234 ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the provider. For example, to remove the OpenStack network provider with identifier `1234`, send a request like this: [source] ---- DELETE /ovirt-engine/api/openstacknetworkproviders/1234 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait) def update( self, provider, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the provider. For example, to update `provider_name`, `requires_authentication`, `url`, `tenant_name` and `type` properties, for the OpenStack network provider with identifier `1234`, send a request like this: [source] ---- PUT /ovirt-engine/api/openstacknetworkproviders/1234 ---- With a request body like this: [source,xml] ---- <openstack_network_provider> <name>ovn-network-provider</name> <requires_authentication>false</requires_authentication> <url>http://some_server_url.domain.com:9696</url> <tenant_name>oVirt</tenant_name> <type>external</type> </openstack_network_provider> ---- This method supports the following parameters: `provider`:: The provider to update. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackNetworkProvider), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(provider, headers, query, wait) def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path) def networks_service(self): """ Reference to OpenStack networks service. """ return OpenstackNetworksService(self._connection, '%s/networks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackNetworkProviderService:%s' % self._path class OpenstackNetworkProvidersService(Service): """ This service manages OpenStack network providers. """ def __init__(self, connection, path): super(OpenstackNetworkProvidersService, self).__init__(connection, path) self._provider_service = None def add( self, provider, headers=None, query=None, wait=True, **kwargs ): """ The operation adds a new network provider to the system. If the `type` property is not present, a default value of `NEUTRON` will be used. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackNetworkProvider), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(provider, headers, query, wait) def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of providers. The order of the returned list of providers isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of providers to return. If not specified all the providers are returned. `search`:: A query string used to restrict the returned OpenStack network providers. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def provider_service(self, id): """ Reference to OpenStack network provider service. """ Service._check_types([ ('id', id, str), ]) return OpenstackNetworkProviderService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.provider_service(path) return self.provider_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackNetworkProvidersService:%s' % self._path class OpenstackNetworksService(Service): """ """ def __init__(self, connection, path): super(OpenstackNetworksService, self).__init__(connection, path) self._network_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of networks. The order of the returned list of networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def network_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackNetworkService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackNetworksService:%s' % self._path class OpenstackSubnetService(Service): """ """ def __init__(self, connection, path): super(OpenstackSubnetService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackSubnetService:%s' % self._path class OpenstackSubnetsService(Service): """ """ def __init__(self, connection, path): super(OpenstackSubnetsService, self).__init__(connection, path) self._subnet_service = None def add( self, subnet, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('subnet', subnet, types.OpenStackSubnet), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(subnet, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of sub-networks. The order of the returned list of sub-networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of sub-networks to return. If not specified all the sub-networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def subnet_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackSubnetService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.subnet_service(path) return self.subnet_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackSubnetsService:%s' % self._path class OpenstackVolumeAuthenticationKeyService(Service): """ """ def __init__(self, connection, path): super(OpenstackVolumeAuthenticationKeyService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, key, headers=None, query=None, wait=True, **kwargs ): """ Update the specified authentication key. """ # Check the types of the parameters: Service._check_types([ ('key', key, types.OpenstackVolumeAuthenticationKey), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(key, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackVolumeAuthenticationKeyService:%s' % self._path class OpenstackVolumeAuthenticationKeysService(Service): """ """ def __init__(self, connection, path): super(OpenstackVolumeAuthenticationKeysService, self).__init__(connection, path) self._key_service = None def add( self, key, headers=None, query=None, wait=True, **kwargs ): """ Add a new authentication key to the OpenStack volume provider. """ # Check the types of the parameters: Service._check_types([ ('key', key, types.OpenstackVolumeAuthenticationKey), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(key, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of authentication keys. The order of the returned list of authentication keys isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of keys to return. If not specified all the keys are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def key_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackVolumeAuthenticationKeyService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.key_service(path) return self.key_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackVolumeAuthenticationKeysService:%s' % self._path class OpenstackVolumeProviderService(ExternalProviderService): """ """ def __init__(self, connection, path): super(OpenstackVolumeProviderService, self).__init__(connection, path) self._authentication_keys_service = None self._certificates_service = None self._volume_types_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait) def remove( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `force`:: Indicates if the operation should succeed, and the provider removed from the database, even if something fails during the operation. This parameter is optional, and the default value is `false`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: self._internal_remove(headers, query, wait) def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait) def update( self, provider, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified OpenStack volume provider in the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackVolumeProvider), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(provider, headers, query, wait) def authentication_keys_service(self): """ """ return OpenstackVolumeAuthenticationKeysService(self._connection, '%s/authenticationkeys' % self._path) def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path) def volume_types_service(self): """ """ return OpenstackVolumeTypesService(self._connection, '%s/volumetypes' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'authenticationkeys': return self.authentication_keys_service() if path.startswith('authenticationkeys/'): return self.authentication_keys_service().service(path[19:]) if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) if path == 'volumetypes': return self.volume_types_service() if path.startswith('volumetypes/'): return self.volume_types_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackVolumeProviderService:%s' % self._path class OpenstackVolumeProvidersService(Service): """ """ def __init__(self, connection, path): super(OpenstackVolumeProvidersService, self).__init__(connection, path) self._provider_service = None def add( self, provider, headers=None, query=None, wait=True, **kwargs ): """ Adds a new volume provider. For example: [source] ---- POST /ovirt-engine/api/openstackvolumeproviders ---- With a request body like this: [source,xml] ---- <openstack_volume_provider> <name>mycinder</name> <url>https://mycinder.example.com:8776</url> <data_center> <name>mydc</name> </data_center> <requires_authentication>true</requires_authentication> <username>admin</username> <password>mypassword</password> <tenant_name>mytenant</tenant_name> </openstack_volume_provider> ---- """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackVolumeProvider), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(provider, headers, query, wait) def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the list of volume providers. The order of the returned list of volume providers isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of providers to return. If not specified all the providers are returned. `search`:: A query string used to restrict the returned volume providers. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def provider_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackVolumeProviderService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.provider_service(path) return self.provider_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackVolumeProvidersService:%s' % self._path class OpenstackVolumeTypeService(Service): """ """ def __init__(self, connection, path): super(OpenstackVolumeTypeService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackVolumeTypeService:%s' % self._path class OpenstackVolumeTypesService(Service): """ """ def __init__(self, connection, path): super(OpenstackVolumeTypesService, self).__init__(connection, path) self._type_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of volume types. The order of the returned list of volume types isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of volume types to return. If not specified all the volume types are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def type_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackVolumeTypeService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.type_service(path) return self.type_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackVolumeTypesService:%s' % self._path class OperatingSystemService(Service): """ """ def __init__(self, connection, path): super(OperatingSystemService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OperatingSystemService:%s' % self._path class OperatingSystemsService(Service): """ Manages the set of types of operating systems available in the system. """ def __init__(self, connection, path): super(OperatingSystemsService, self).__init__(connection, path) self._operating_system_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of types of operating system available in the system. The order of the returned list of operating systems isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def operating_system_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OperatingSystemService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.operating_system_service(path) return self.operating_system_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OperatingSystemsService:%s' % self._path class PermissionService(Service): """ """ def __init__(self, connection, path): super(PermissionService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'PermissionService:%s' % self._path class PermitService(Service): """ A service to manage a specific permit of the role. """ def __init__(self, connection, path): super(PermitService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the information about the permit of the role. For example to retrieve the information about the permit with the id `456` of the role with the id `123` send a request like this: .... GET /ovirt-engine/api/roles/123/permits/456 .... [source,xml] ---- <permit href="/ovirt-engine/api/roles/123/permits/456" id="456"> <name>change_vm_cd</name> <administrative>false</administrative> <role href="/ovirt-engine/api/roles/123" id="123"/> </permit> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the permit from the role. For example to remove the permit with id `456` from the role with id `123` send a request like this: .... DELETE /ovirt-engine/api/roles/123/permits/456 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'PermitService:%s' % self._path class PermitsService(Service): """ Represents a permits sub-collection of the specific role. """ def __init__(self, connection, path): super(PermitsService, self).__init__(connection, path) self._permit_service = None def add( self, permit, headers=None, query=None, wait=True, **kwargs ): """ Adds a permit to the role. The permit name can be retrieved from the <<services/cluster_levels>> service. For example to assign a permit `create_vm` to the role with id `123` send a request like this: .... POST /ovirt-engine/api/roles/123/permits .... With a request body like this: [source,xml] ---- <permit> <name>create_vm</name> </permit> ---- This method supports the following parameters: `permit`:: The permit to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permit', permit, types.Permit), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permit, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the permits of the role. For example to list the permits of the role with the id `123` send a request like this: .... GET /ovirt-engine/api/roles/123/permits .... [source,xml] ---- <permits> <permit href="/ovirt-engine/api/roles/123/permits/5" id="5"> <name>change_vm_cd</name> <administrative>false</administrative> <role href="/ovirt-engine/api/roles/123" id="123"/> </permit> <permit href="/ovirt-engine/api/roles/123/permits/7" id="7"> <name>connect_to_vm</name> <administrative>false</administrative> <role href="/ovirt-engine/api/roles/123" id="123"/> </permit> </permits> ---- The order of the returned list of permits isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of permits to return. If not specified all the permits are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def permit_service(self, id): """ Sub-resource locator method, returns individual permit resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return PermitService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.permit_service(path) return self.permit_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'PermitsService:%s' % self._path class QosService(Service): """ """ def __init__(self, connection, path): super(QosService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get specified QoS in the data center. [source] ---- GET /ovirt-engine/api/datacenters/123/qoss/123 ---- You will get response like this one below: [source,xml] ---- <qos href="/ovirt-engine/api/datacenters/123/qoss/123" id="123"> <name>123</name> <description>123</description> <max_iops>1</max_iops> <max_throughput>1</max_throughput> <type>storage</type> <data_center href="/ovirt-engine/api/datacenters/123" id="123"/> </qos> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove specified QoS from datacenter. [source] ---- DELETE /ovirt-engine/api/datacenters/123/qoss/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, qos, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified QoS in the dataCenter. [source] ---- PUT /ovirt-engine/api/datacenters/123/qoss/123 ---- For example with curl: [source] ---- curl -u admin@internal:123456 -X PUT -H "content-type: application/xml" -d \ "<qos><name>321</name><description>321</description><max_iops>10</max_iops></qos>" \ https://engine/ovirt-engine/api/datacenters/123/qoss/123 ---- You will receive response like this: [source,xml] ---- <qos href="/ovirt-engine/api/datacenters/123/qoss/123" id="123"> <name>321</name> <description>321</description> <max_iops>10</max_iops> <max_throughput>1</max_throughput> <type>storage</type> <data_center href="/ovirt-engine/api/datacenters/123" id="123"/> </qos> ---- This method supports the following parameters: `qos`:: Updated QoS object. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('qos', qos, types.Qos), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(qos, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'QosService:%s' % self._path class QossService(Service): """ Manages the set of _quality of service_ configurations available in a data center. """ def __init__(self, connection, path): super(QossService, self).__init__(connection, path) self._qos_service = None def add( self, qos, headers=None, query=None, wait=True, **kwargs ): """ Add a new QoS to the dataCenter. [source] ---- POST /ovirt-engine/api/datacenters/123/qoss ---- The response will look as follows: [source,xml] ---- <qos href="/ovirt-engine/api/datacenters/123/qoss/123" id="123"> <name>123</name> <description>123</description> <max_iops>10</max_iops> <type>storage</type> <data_center href="/ovirt-engine/api/datacenters/123" id="123"/> </qos> ---- This method supports the following parameters: `qos`:: Added QoS object. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('qos', qos, types.Qos), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(qos, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of _quality of service_ configurations available in the data center. [source] ---- GET /ovirt-engine/api/datacenter/123/qoss ---- You will get response which will look like this: [source, xml] ---- <qoss> <qos href="/ovirt-engine/api/datacenters/123/qoss/1" id="1">...</qos> <qos href="/ovirt-engine/api/datacenters/123/qoss/2" id="2">...</qos> <qos href="/ovirt-engine/api/datacenters/123/qoss/3" id="3">...</qos> </qoss> ---- The returned list of quality of service configurations isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of QoS descriptors to return. If not specified all the descriptors are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def qos_service(self, id): """ A reference to a service managing a specific QoS. """ Service._check_types([ ('id', id, str), ]) return QosService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.qos_service(path) return self.qos_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'QossService:%s' % self._path class QuotaService(Service): """ """ def __init__(self, connection, path): super(QuotaService, self).__init__(connection, path) self._permissions_service = None self._quota_cluster_limits_service = None self._quota_storage_limits_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a quota. An example of retrieving a quota: [source] ---- GET /ovirt-engine/api/datacenters/123/quotas/456 ---- [source,xml] ---- <quota id="456"> <name>myquota</name> <description>My new quota for virtual machines</description> <cluster_hard_limit_pct>20</cluster_hard_limit_pct> <cluster_soft_limit_pct>80</cluster_soft_limit_pct> <storage_hard_limit_pct>20</storage_hard_limit_pct> <storage_soft_limit_pct>80</storage_soft_limit_pct> </quota> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Delete a quota. An example of deleting a quota: [source] ---- DELETE /ovirt-engine/api/datacenters/123-456/quotas/654-321 -0472718ab224 HTTP/1.1 Accept: application/xml Content-type: application/xml ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, quota, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a quota. An example of updating a quota: [source] ---- PUT /ovirt-engine/api/datacenters/123/quotas/456 ---- [source,xml] ---- <quota> <cluster_hard_limit_pct>30</cluster_hard_limit_pct> <cluster_soft_limit_pct>70</cluster_soft_limit_pct> <storage_hard_limit_pct>20</storage_hard_limit_pct> <storage_soft_limit_pct>80</storage_soft_limit_pct> </quota> ---- """ # Check the types of the parameters: Service._check_types([ ('quota', quota, types.Quota), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(quota, headers, query, wait) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def quota_cluster_limits_service(self): """ """ return QuotaClusterLimitsService(self._connection, '%s/quotaclusterlimits' % self._path) def quota_storage_limits_service(self): """ """ return QuotaStorageLimitsService(self._connection, '%s/quotastoragelimits' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'quotaclusterlimits': return self.quota_cluster_limits_service() if path.startswith('quotaclusterlimits/'): return self.quota_cluster_limits_service().service(path[19:]) if path == 'quotastoragelimits': return self.quota_storage_limits_service() if path.startswith('quotastoragelimits/'): return self.quota_storage_limits_service().service(path[19:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'QuotaService:%s' % self._path class QuotaClusterLimitService(Service): """ """ def __init__(self, connection, path): super(QuotaClusterLimitService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'QuotaClusterLimitService:%s' % self._path class QuotaClusterLimitsService(Service): """ Manages the set of quota limits configured for a cluster. """ def __init__(self, connection, path): super(QuotaClusterLimitsService, self).__init__(connection, path) self._limit_service = None def add( self, limit, headers=None, query=None, wait=True, **kwargs ): """ Add a cluster limit to a specified Quota. """ # Check the types of the parameters: Service._check_types([ ('limit', limit, types.QuotaClusterLimit), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(limit, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the set of quota limits configured for the cluster. The returned list of quota limits isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of limits to return. If not specified all the limits are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def limit_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return QuotaClusterLimitService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.limit_service(path) return self.limit_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'QuotaClusterLimitsService:%s' % self._path class QuotaStorageLimitService(Service): """ """ def __init__(self, connection, path): super(QuotaStorageLimitService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the update should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'QuotaStorageLimitService:%s' % self._path class QuotaStorageLimitsService(Service): """ Manages the set of storage limits configured for a quota. """ def __init__(self, connection, path): super(QuotaStorageLimitsService, self).__init__(connection, path) self._limit_service = None def add( self, limit, headers=None, query=None, wait=True, **kwargs ): """ Adds a storage limit to a specified quota. To create a 100GiB storage limit for all storage domains in a data center, send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/quotas/456/quotastoragelimits ---- With a request body like this: [source,xml] ---- <quota_storage_limit> <limit>100</limit> </quota_storage_limit> ---- To create a 50GiB storage limit for a storage domain with the ID `000`, send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/quotas/456/quotastoragelimits ---- With a request body like this: [source,xml] ---- <quota_storage_limit> <limit>50</limit> <storage_domain id="000"/> </quota_storage_limit> ---- """ # Check the types of the parameters: Service._check_types([ ('limit', limit, types.QuotaStorageLimit), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(limit, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of storage limits configured for the quota. The order of the returned list of storage limits is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of limits to return. If not specified, all the limits are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def limit_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return QuotaStorageLimitService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.limit_service(path) return self.limit_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'QuotaStorageLimitsService:%s' % self._path class QuotasService(Service): """ Manages the set of quotas configured for a data center. """ def __init__(self, connection, path): super(QuotasService, self).__init__(connection, path) self._quota_service = None def add( self, quota, headers=None, query=None, wait=True, **kwargs ): """ Creates a new quota. An example of creating a new quota: [source] ---- POST /ovirt-engine/api/datacenters/123/quotas ---- [source,xml] ---- <quota> <name>myquota</name> <description>My new quota for virtual machines</description> </quota> ---- """ # Check the types of the parameters: Service._check_types([ ('quota', quota, types.Quota), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(quota, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists quotas of a data center. The order of the returned list of quotas isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of quota descriptors to return. If not specified all the descriptors are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def quota_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return QuotaService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.quota_service(path) return self.quota_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'QuotasService:%s' % self._path class RoleService(Service): """ """ def __init__(self, connection, path): super(RoleService, self).__init__(connection, path) self._permits_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get the role. [source] ---- GET /ovirt-engine/api/roles/123 ---- You will receive XML response like this one: [source,xml] ---- <role id="123"> <name>MyRole</name> <description>MyRole description</description> <link href="/ovirt-engine/api/roles/123/permits" rel="permits"/> <administrative>true</administrative> <mutable>false</mutable> </role> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the role. To remove the role you need to know its id, then send request like this: [source] ---- DELETE /ovirt-engine/api/roles/{role_id} ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, role, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a role. You are allowed to update `name`, `description` and `administrative` attributes after role is created. Within this endpoint you can't add or remove roles permits you need to use <<services/permits, service>> that manages permits of role. For example to update role's `name`, `description` and `administrative` attributes send a request like this: [source] ---- PUT /ovirt-engine/api/roles/123 ---- With a request body like this: [source,xml] ---- <role> <name>MyNewRoleName</name> <description>My new description of the role</description> <administrative>true</administrative> </group> ---- This method supports the following parameters: `role`:: Updated role. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('role', role, types.Role), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(role, headers, query, wait) def permits_service(self): """ Sub-resource locator method, returns permits service. """ return PermitsService(self._connection, '%s/permits' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permits': return self.permits_service() if path.startswith('permits/'): return self.permits_service().service(path[8:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'RoleService:%s' % self._path class RolesService(Service): """ Provides read-only access to the global set of roles """ def __init__(self, connection, path): super(RolesService, self).__init__(connection, path) self._role_service = None def add( self, role, headers=None, query=None, wait=True, **kwargs ): """ Create a new role. The role can be administrative or non-administrative and can have different permits. For example, to add the `MyRole` non-administrative role with permits to login and create virtual machines send a request like this (note that you have to pass permit id): [source] ---- POST /ovirt-engine/api/roles ---- With a request body like this: [source,xml] ---- <role> <name>MyRole</name> <description>My custom role to create virtual machines</description> <administrative>false</administrative> <permits> <permit id="1"/> <permit id="1300"/> </permits> </group> ---- This method supports the following parameters: `role`:: Role that will be added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('role', role, types.Role), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(role, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List roles. [source] ---- GET /ovirt-engine/api/roles ---- You will receive response in XML like this one: [source,xml] ---- <roles> <role id="123"> <name>SuperUser</name> <description>Roles management administrator</description> <link href="/ovirt-engine/api/roles/123/permits" rel="permits"/> <administrative>true</administrative> <mutable>false</mutable> </role> ... </roles> ---- The order of the returned list of roles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of roles to return. If not specified all the roles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def role_service(self, id): """ Sub-resource locator method, returns individual role resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return RoleService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.role_service(path) return self.role_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'RolesService:%s' % self._path class SchedulingPoliciesService(Service): """ Manages the set of scheduling policies available in the system. """ def __init__(self, connection, path): super(SchedulingPoliciesService, self).__init__(connection, path) self._policy_service = None def add( self, policy, headers=None, query=None, wait=True, **kwargs ): """ Add a new scheduling policy to the system. """ # Check the types of the parameters: Service._check_types([ ('policy', policy, types.SchedulingPolicy), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(policy, headers, query, wait) def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of scheduling policies available in the system. The order of the returned list of scheduling policies isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of policies to return. If not specified all the policies are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def policy_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SchedulingPolicyService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.policy_service(path) return self.policy_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SchedulingPoliciesService:%s' % self._path class SchedulingPolicyService(Service): """ """ def __init__(self, connection, path): super(SchedulingPolicyService, self).__init__(connection, path) self._balances_service = None self._filters_service = None self._weights_service = None def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, policy, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified user defined scheduling policy in the system. """ # Check the types of the parameters: Service._check_types([ ('policy', policy, types.SchedulingPolicy), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(policy, headers, query, wait) def balances_service(self): """ """ return BalancesService(self._connection, '%s/balances' % self._path) def filters_service(self): """ """ return FiltersService(self._connection, '%s/filters' % self._path) def weights_service(self): """ """ return WeightsService(self._connection, '%s/weights' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'balances': return self.balances_service() if path.startswith('balances/'): return self.balances_service().service(path[9:]) if path == 'filters': return self.filters_service() if path.startswith('filters/'): return self.filters_service().service(path[8:]) if path == 'weights': return self.weights_service() if path.startswith('weights/'): return self.weights_service().service(path[8:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SchedulingPolicyService:%s' % self._path class SchedulingPolicyUnitService(Service): """ """ def __init__(self, connection, path): super(SchedulingPolicyUnitService, self).__init__(connection, path) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SchedulingPolicyUnitService:%s' % self._path class SchedulingPolicyUnitsService(Service): """ Manages the set of scheduling policy units available in the system. """ def __init__(self, connection, path): super(SchedulingPolicyUnitsService, self).__init__(connection, path) self._unit_service = None def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of scheduling policy units available in the system. The order of the returned list of scheduling policy units isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of policy units to return. If not specified all the policy units are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def unit_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SchedulingPolicyUnitService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.unit_service(path) return self.unit_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SchedulingPolicyUnitsService:%s' % self._path class SnapshotService(Service): """ """ def __init__(self, connection, path): super(SnapshotService, self).__init__(connection, path) self._cdroms_service = None self._disks_service = None self._nics_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, all_content=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `all_content`:: Indicates if all the attributes of the virtual machine snapshot should be included in the response. By default the attribute `initialization.configuration.data` is excluded. For example, to retrieve the complete representation of the snapshot with id `456` of the virtual machine with id `123` send a request like this: .... GET /ovirt-engine/api/vms/123/snapshots/456?all_content=true .... `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('all_content', all_content, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content # Send the request and wait for the response: self._internal_remove(headers, query, wait) def restore( self, async_=None, disks=None, restore_memory=None, headers=None, query=None, wait=True, **kwargs ): """ Restores a virtual machine snapshot. For example, to restore the snapshot with identifier `456` of virtual machine with identifier `123` send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/snapshots/456/restore ---- With an empty `action` in the body: [source,xml] ---- <action/> ---- NOTE: Confirm that the commit operation is finished and the virtual machine is down before running the virtual machine. This method supports the following parameters: `disks`:: Specify the disks included in the snapshot's restore. For each disk parameter, it is also required to specify its `image_id`. For example, to restore a snapshot with an identifier `456` of a virtual machine with identifier `123`, including a disk with identifier `111` and `image_id` of `222`, send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/snapshots/456/restore ---- Request body: [source,xml] ---- <action> <disks> <disk id="111"> <image_id>222</image_id> </disk> </disks> </action> ---- `async_`:: Indicates if the restore should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('disks', disks, list), ('restore_memory', restore_memory, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, disks=disks, restore_memory=restore_memory, ) # Send the request and wait for the response: return self._internal_action(action, 'restore', None, headers, query, wait) def cdroms_service(self): """ """ return SnapshotCdromsService(self._connection, '%s/cdroms' % self._path) def disks_service(self): """ """ return SnapshotDisksService(self._connection, '%s/disks' % self._path) def nics_service(self): """ """ return SnapshotNicsService(self._connection, '%s/nics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'cdroms': return self.cdroms_service() if path.startswith('cdroms/'): return self.cdroms_service().service(path[7:]) if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SnapshotService:%s' % self._path class SnapshotCdromService(Service): """ """ def __init__(self, connection, path): super(SnapshotCdromService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SnapshotCdromService:%s' % self._path class SnapshotCdromsService(Service): """ Manages the set of CD-ROM devices of a virtual machine snapshot. """ def __init__(self, connection, path): super(SnapshotCdromsService, self).__init__(connection, path) self._cdrom_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of CD-ROM devices of the snapshot. The order of the returned list of CD-ROM devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of CDROMS to return. If not specified all the CDROMS are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def cdrom_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SnapshotCdromService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.cdrom_service(path) return self.cdrom_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SnapshotCdromsService:%s' % self._path class SnapshotDiskService(Service): """ """ def __init__(self, connection, path): super(SnapshotDiskService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SnapshotDiskService:%s' % self._path class SnapshotDisksService(Service): """ Manages the set of disks of an snapshot. """ def __init__(self, connection, path): super(SnapshotDisksService, self).__init__(connection, path) self._disk_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks of the snapshot. The order of the returned list of disks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SnapshotDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SnapshotDisksService:%s' % self._path class SnapshotNicService(Service): """ """ def __init__(self, connection, path): super(SnapshotNicService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SnapshotNicService:%s' % self._path class SnapshotNicsService(Service): """ Manages the set of NICs of an snapshot. """ def __init__(self, connection, path): super(SnapshotNicsService, self).__init__(connection, path) self._nic_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of NICs of the snapshot. The order of the returned list of NICs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def nic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SnapshotNicService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SnapshotNicsService:%s' % self._path class SnapshotsService(Service): """ Manages the set of snapshots of a storage domain or virtual machine. """ def __init__(self, connection, path): super(SnapshotsService, self).__init__(connection, path) self._snapshot_service = None def add( self, snapshot, headers=None, query=None, wait=True, **kwargs ): """ Creates a virtual machine snapshot. For example, to create a new snapshot for virtual machine `123` send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/snapshots ---- With a request body like this: [source,xml] ---- <snapshot> <description>My snapshot</description> </snapshot> ---- For including only a sub-set of disks in the snapshots, add `disk_attachments` element to the request body. Note that disks which are not specified in `disk_attachments` element will not be a part of the snapshot. If an empty `disk_attachments` element is passed, the snapshot will include only the virtual machine configuration. If no `disk_attachments` element is passed, then all the disks will be included in the snapshot. For each disk, `image_id` element can be specified for setting the new active image id. This is used in order to restore a chain of images from backup. I.e. when restoring a disk with snapshots, the relevant `image_id` should be specified for each snapshot (so the identifiers of the disk snapshots are identical to the backup). [source,xml] ---- <snapshot> <description>My snapshot</description> <disk_attachments> <disk_attachment> <disk id="123"> <image_id>456</image_id> </disk> </disk_attachment> </disk_attachments> </snapshot> ---- [IMPORTANT] ==== When a snapshot is created the default value for the <<types/snapshot/attributes/persist_memorystate, persist_memorystate>> attribute is `true`. That means that the content of the memory of the virtual machine will be included in the snapshot, and it also means that the virtual machine will be paused for a longer time. That can negatively affect applications that are very sensitive to timing (NTP servers, for example). In those cases make sure that you set the attribute to `false`: [source,xml] ---- <snapshot> <description>My snapshot</description> <persist_memorystate>false</persist_memorystate> </snapshot> ---- ==== """ # Check the types of the parameters: Service._check_types([ ('snapshot', snapshot, types.Snapshot), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(snapshot, headers, query, wait) def list( self, all_content=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of snapshots of the storage domain or virtual machine. The order of the returned list of snapshots isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of snapshots to return. If not specified all the snapshots are returned. `all_content`:: Indicates if all the attributes of the virtual machine snapshot should be included in the response. By default the attribute `initialization.configuration.data` is excluded. For example, to retrieve the complete representation of the virtual machine with id `123` snapshots send a request like this: .... GET /ovirt-engine/api/vms/123/snapshots?all_content=true .... `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def snapshot_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SnapshotService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.snapshot_service(path) return self.snapshot_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SnapshotsService:%s' % self._path class SshPublicKeyService(Service): """ """ def __init__(self, connection, path): super(SshPublicKeyService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, key, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Replaces the key with a new resource. IMPORTANT: Since version 4.4.8 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. Instead please use DELETE followed by <<services/ssh_public_keys/methods/add, add operation>>. """ # Check the types of the parameters: Service._check_types([ ('key', key, types.SshPublicKey), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(key, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SshPublicKeyService:%s' % self._path class SshPublicKeysService(Service): """ """ def __init__(self, connection, path): super(SshPublicKeysService, self).__init__(connection, path) self._key_service = None def add( self, key, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('key', key, types.SshPublicKey), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(key, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns a list of SSH public keys of the user. For example, to retrieve the list of SSH keys of user with identifier `123`, send a request like this: [source] ---- GET /ovirt-engine/api/users/123/sshpublickeys ---- The result will be the following XML document: [source,xml] ---- <ssh_public_keys> <ssh_public_key href="/ovirt-engine/api/users/123/sshpublickeys/456" id="456"> <content>ssh-rsa ...</content> <user href="/ovirt-engine/api/users/123" id="123"/> </ssh_public_key> </ssh_public_keys> ---- Or the following JSON object [source,json] ---- { "ssh_public_key": [ { "content": "ssh-rsa ...", "user": { "href": "/ovirt-engine/api/users/123", "id": "123" }, "href": "/ovirt-engine/api/users/123/sshpublickeys/456", "id": "456" } ] } ---- The order of the returned list of keys is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of keys to return. If not specified all the keys are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def key_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SshPublicKeyService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.key_service(path) return self.key_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SshPublicKeysService:%s' % self._path class StatisticService(Service): """ """ def __init__(self, connection, path): super(StatisticService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StatisticService:%s' % self._path class StatisticsService(Service): """ """ def __init__(self, connection, path): super(StatisticsService, self).__init__(connection, path) self._statistic_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a list of statistics. For example, to retrieve the statistics for virtual machine `123` send a request like this: [source] ---- GET /ovirt-engine/api/vms/123/statistics ---- The result will be like this: [source,xml] ---- <statistics> <statistic href="/ovirt-engine/api/vms/123/statistics/456" id="456"> <name>memory.installed</name> <description>Total memory configured</description> <kind>gauge</kind> <type>integer</type> <unit>bytes</unit> <values> <value> <datum>1073741824</datum> </value> </values> <vm href="/ovirt-engine/api/vms/123" id="123"/> </statistic> ... </statistics> ---- Just a single part of the statistics can be retrieved by specifying its id at the end of the URI. That means: [source] ---- GET /ovirt-engine/api/vms/123/statistics/456 ---- Outputs: [source,xml] ---- <statistic href="/ovirt-engine/api/vms/123/statistics/456" id="456"> <name>memory.installed</name> <description>Total memory configured</description> <kind>gauge</kind> <type>integer</type> <unit>bytes</unit> <values> <value> <datum>1073741824</datum> </value> </values> <vm href="/ovirt-engine/api/vms/123" id="123"/> </statistic> ---- The order of the returned list of statistics isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of statistics to return. If not specified all the statistics are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def statistic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StatisticService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.statistic_service(path) return self.statistic_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StatisticsService:%s' % self._path class StepService(MeasurableService): """ A service to manage a step. """ def __init__(self, connection, path): super(StepService, self).__init__(connection, path) self._statistics_service = None def end( self, async_=None, force=None, succeeded=None, headers=None, query=None, wait=True, **kwargs ): """ Marks an external step execution as ended. For example, to terminate a step with identifier `456` which belongs to a `job` with identifier `123` send the following request: [source] ---- POST /ovirt-engine/api/jobs/123/steps/456/end ---- With the following request body: [source,xml] ---- <action> <force>true</force> <succeeded>true</succeeded> </action> ---- This method supports the following parameters: `force`:: Indicates if the step should be forcibly terminated. `succeeded`:: Indicates if the step should be marked as successfully finished or as failed. This parameter is optional, and the default value is `true`. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('succeeded', succeeded, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, succeeded=succeeded, ) # Send the request and wait for the response: return self._internal_action(action, 'end', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a step. [source] ---- GET /ovirt-engine/api/jobs/123/steps/456 ---- You will receive response in XML like this one: [source,xml] ---- <step href="/ovirt-engine/api/jobs/123/steps/456" id="456"> <actions> <link href="/ovirt-engine/api/jobs/123/steps/456/end" rel="end"/> </actions> <description>Validating</description> <end_time>2016-12-12T23:07:26.627+02:00</end_time> <external>false</external> <number>0</number> <start_time>2016-12-12T23:07:26.605+02:00</start_time> <status>finished</status> <type>validating</type> <job href="/ovirt-engine/api/jobs/123" id="123"/> </step> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StepService:%s' % self._path class StepsService(Service): """ A service to manage steps. """ def __init__(self, connection, path): super(StepsService, self).__init__(connection, path) self._step_service = None def add( self, step, headers=None, query=None, wait=True, **kwargs ): """ Add an external step to an existing job or to an existing step. For example, to add a step to `job` with identifier `123` send the following request: [source] ---- POST /ovirt-engine/api/jobs/123/steps ---- With the following request body: [source,xml] ---- <step> <description>Validating</description> <start_time>2016-12-12T23:07:26.605+02:00</start_time> <status>started</status> <type>validating</type> </step> ---- The response should look like: [source,xml] ---- <step href="/ovirt-engine/api/jobs/123/steps/456" id="456"> <actions> <link href="/ovirt-engine/api/jobs/123/steps/456/end" rel="end"/> </actions> <description>Validating</description> <link href="/ovirt-engine/api/jobs/123/steps/456/statistics" rel="statistics"/> <external>true</external> <number>2</number> <start_time>2016-12-13T01:06:15.380+02:00</start_time> <status>started</status> <type>validating</type> <job href="/ovirt-engine/api/jobs/123" id="123"/> </step> ---- This method supports the following parameters: `step`:: Step that will be added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('step', step, types.Step), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(step, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representation of the steps. [source] ---- GET /ovirt-engine/api/job/123/steps ---- You will receive response in XML like this one: [source,xml] ---- <steps> <step href="/ovirt-engine/api/jobs/123/steps/456" id="456"> <actions> <link href="/ovirt-engine/api/jobs/123/steps/456/end" rel="end"/> </actions> <description>Validating</description> <link href="/ovirt-engine/api/jobs/123/steps/456/statistics" rel="statistics"/> <external>true</external> <number>2</number> <start_time>2016-12-13T01:06:15.380+02:00</start_time> <status>started</status> <type>validating</type> <job href="/ovirt-engine/api/jobs/123" id="123"/> </step> ... </steps> ---- The order of the returned list of steps isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of steps to return. If not specified all the steps are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def step_service(self, id): """ Reference to the step service. """ Service._check_types([ ('id', id, str), ]) return StepService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.step_service(path) return self.step_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StepsService:%s' % self._path class StorageService(Service): """ """ def __init__(self, connection, path): super(StorageService, self).__init__(connection, path) def get( self, follow=None, report_status=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `report_status`:: Indicates if the status of the LUNs in the storage should be checked. Checking the status of the LUN is an heavy weight operation and this data is not always needed by the user. This parameter will give the option to not perform the status check of the LUNs. The default is `true` for backward compatibility. Here an example with the LUN status : [source,xml] ---- <host_storage id="360014051136c20574f743bdbd28177fd"> <logical_units> <logical_unit id="360014051136c20574f743bdbd28177fd"> <lun_mapping>0</lun_mapping> <paths>1</paths> <product_id>lun0</product_id> <serial>SLIO-ORG_lun0_1136c205-74f7-43bd-bd28-177fd5ce6993</serial> <size>10737418240</size> <status>used</status> <vendor_id>LIO-ORG</vendor_id> <volume_group_id>O9Du7I-RahN-ECe1-dZ1w-nh0b-64io-MNzIBZ</volume_group_id> </logical_unit> </logical_units> <type>iscsi</type> <host id="8bb5ade5-e988-4000-8b93-dbfc6717fe50"/> </host_storage> ---- Here an example without the LUN status : [source,xml] ---- <host_storage id="360014051136c20574f743bdbd28177fd"> <logical_units> <logical_unit id="360014051136c20574f743bdbd28177fd"> <lun_mapping>0</lun_mapping> <paths>1</paths> <product_id>lun0</product_id> <serial>SLIO-ORG_lun0_1136c205-74f7-43bd-bd28-177fd5ce6993</serial> <size>10737418240</size> <vendor_id>LIO-ORG</vendor_id> <volume_group_id>O9Du7I-RahN-ECe1-dZ1w-nh0b-64io-MNzIBZ</volume_group_id> </logical_unit> </logical_units> <type>iscsi</type> <host id="8bb5ade5-e988-4000-8b93-dbfc6717fe50"/> </host_storage> ---- `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('report_status', report_status, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if report_status is not None: report_status = Writer.render_boolean(report_status) query['report_status'] = report_status # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageService:%s' % self._path class StorageDomainService(Service): """ """ def __init__(self, connection, path): super(StorageDomainService, self).__init__(connection, path) self._disk_profiles_service = None self._disk_snapshots_service = None self._disks_service = None self._files_service = None self._images_service = None self._permissions_service = None self._storage_connections_service = None self._templates_service = None self._vms_service = None def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the storage domain. This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def is_attached( self, async_=None, host=None, headers=None, query=None, wait=True, **kwargs ): """ Used for querying if the storage domain is already attached to a data center using the is_attached boolean field, which is part of the storage server. IMPORTANT: Executing this API will cause the host to disconnect from the storage domain. This method supports the following parameters: `host`:: Indicates the data center's host. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('host', host, types.Host), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, host=host, ) # Send the request and wait for the response: return self._internal_action(action, 'isattached', 'is_attached', headers, query, wait) def reduce_luns( self, logical_units=None, headers=None, query=None, wait=True, **kwargs ): """ This operation reduces logical units from the storage domain. In order to do so the data stored on the provided logical units will be moved to other logical units of the storage domain and only then they will be reduced from the storage domain. For example, in order to reduce two logical units from a storage domain send a request like this: [source] ---- POST /ovirt-engine/api/storageDomains/123/reduceluns ---- With a request body like this: [source,xml] ---- <action> <logical_units> <logical_unit id="1IET_00010001"/> <logical_unit id="1IET_00010002"/> </logical_units> </action> ---- Note that this operation is only applicable to block storage domains (i.e., storage domains with the <<types/storage_type, storage type> of iSCSI or FCP). This method supports the following parameters: `logical_units`:: The logical units that need to be reduced from the storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('logical_units', logical_units, list), ]) # Populate the action: action = types.Action( logical_units=logical_units, ) # Send the request and wait for the response: return self._internal_action(action, 'reduceluns', None, headers, query, wait) def refresh_luns( self, async_=None, logical_units=None, headers=None, query=None, wait=True, **kwargs ): """ This operation refreshes the LUN size. After increasing the size of the underlying LUN on the storage server, the user can refresh the LUN size. This action forces a rescan of the provided LUNs and updates the database with the new size, if required. For example, in order to refresh the size of two LUNs send a request like this: [source] ---- POST /ovirt-engine/api/storageDomains/262b056b-aede-40f1-9666-b883eff59d40/refreshluns ---- With a request body like this: [source,xml] ---- <action> <logical_units> <logical_unit id="1IET_00010001"/> <logical_unit id="1IET_00010002"/> </logical_units> </action> ---- This method supports the following parameters: `logical_units`:: The LUNs that need to be refreshed. `async_`:: Indicates if the refresh should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('logical_units', logical_units, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, logical_units=logical_units, ) # Send the request and wait for the response: return self._internal_action(action, 'refreshluns', None, headers, query, wait) def remove( self, host=None, format=None, destroy=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the storage domain. Without any special parameters, the storage domain is detached from the system and removed from the database. The storage domain can then be imported to the same or to a different setup, with all the data on it. If the storage is not accessible the operation will fail. If the `destroy` parameter is `true` then the operation will always succeed, even if the storage is not accessible, the failure is just ignored and the storage domain is removed from the database anyway. If the `format` parameter is `true` then the actual storage is formatted, and the metadata is removed from the LUN or directory, so it can no longer be imported to the same or to a different setup. This method supports the following parameters: `host`:: Indicates which host should be used to remove the storage domain. This parameter is mandatory, except if the `destroy` parameter is included and its value is `true`, in that case the `host` parameter will be ignored. The value should contain the name or the identifier of the host. For example, to use the host named `myhost` to remove the storage domain with identifier `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/storageDomains/123?host=myhost ---- `format`:: Indicates if the actual storage should be formatted, removing all the metadata from the underlying LUN or directory: [source] ---- DELETE /ovirt-engine/api/storageDomains/123?format=true ---- This parameter is optional, and the default value is `false`. `destroy`:: Indicates if the operation should succeed, and the storage domain removed from the database, even if the storage is not accessible. [source] ---- DELETE /ovirt-engine/api/storageDomains/123?destroy=true ---- This parameter is optional, and the default value is `false`. When the value of `destroy` is `true` the `host` parameter will be ignored. `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, str), ('format', format, bool), ('destroy', destroy, bool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if host is not None: query['host'] = host if format is not None: format = Writer.render_boolean(format) query['format'] = format if destroy is not None: destroy = Writer.render_boolean(destroy) query['destroy'] = destroy if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, storage_domain, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a storage domain. Not all of the <<types/storage_domain,StorageDomain>>'s attributes are updatable after creation. Those that can be updated are: `name`, `description`, `comment`, `warning_low_space_indicator`, `critical_space_action_blocker` and `wipe_after_delete.` (Note that changing the `wipe_after_delete` attribute will not change the wipe after delete property of disks that already exist). To update the `name` and `wipe_after_delete` attributes of a storage domain with an identifier `123`, send a request as follows: [source] ---- PUT /ovirt-engine/api/storageDomains/123 ---- With a request body as follows: [source,xml] ---- <storage_domain> <name>data2</name> <wipe_after_delete>true</wipe_after_delete> </storage_domain> ---- This method supports the following parameters: `storage_domain`:: The updated storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(storage_domain, headers, query, wait) def update_ovf_store( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation forces the update of the `OVF_STORE` of this storage domain. The `OVF_STORE` is a disk image that contains the metadata of virtual machines and disks that reside in the storage domain. This metadata is used in case the domain is imported or exported to or from a different data center or a different installation. By default the `OVF_STORE` is updated periodically (set by default to 60 minutes) but users might want to force an update after an important change, or when the they believe the `OVF_STORE` is corrupt. When initiated by the user, `OVF_STORE` update will be performed whether an update is needed or not. This method supports the following parameters: `async_`:: Indicates if the `OVF_STORE` update should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'updateovfstore', None, headers, query, wait) def disk_profiles_service(self): """ """ return AssignedDiskProfilesService(self._connection, '%s/diskprofiles' % self._path) def disk_snapshots_service(self): """ """ return DiskSnapshotsService(self._connection, '%s/disksnapshots' % self._path) def disks_service(self): """ Reference to the service that manages the disks available in the storage domain. """ return StorageDomainDisksService(self._connection, '%s/disks' % self._path) def files_service(self): """ Returns a reference to the service that manages the files available in the storage domain. """ return FilesService(self._connection, '%s/files' % self._path) def images_service(self): """ """ return ImagesService(self._connection, '%s/images' % self._path) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def storage_connections_service(self): """ Returns a reference to the service that manages the storage connections. """ return StorageDomainServerConnectionsService(self._connection, '%s/storageconnections' % self._path) def templates_service(self): """ """ return StorageDomainTemplatesService(self._connection, '%s/templates' % self._path) def vms_service(self): """ """ return StorageDomainVmsService(self._connection, '%s/vms' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'diskprofiles': return self.disk_profiles_service() if path.startswith('diskprofiles/'): return self.disk_profiles_service().service(path[13:]) if path == 'disksnapshots': return self.disk_snapshots_service() if path.startswith('disksnapshots/'): return self.disk_snapshots_service().service(path[14:]) if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) if path == 'files': return self.files_service() if path.startswith('files/'): return self.files_service().service(path[6:]) if path == 'images': return self.images_service() if path.startswith('images/'): return self.images_service().service(path[7:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'storageconnections': return self.storage_connections_service() if path.startswith('storageconnections/'): return self.storage_connections_service().service(path[19:]) if path == 'templates': return self.templates_service() if path.startswith('templates/'): return self.templates_service().service(path[10:]) if path == 'vms': return self.vms_service() if path.startswith('vms/'): return self.vms_service().service(path[4:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageDomainService:%s' % self._path class StorageDomainContentDiskService(Service): """ """ def __init__(self, connection, path): super(StorageDomainContentDiskService, self).__init__(connection, path) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageDomainContentDiskService:%s' % self._path class StorageDomainContentDisksService(Service): """ Manages the set of disks available in a storage domain. """ def __init__(self, connection, path): super(StorageDomainContentDisksService, self).__init__(connection, path) self._disk_service = None def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks available in the storage domain. The order of the returned list of disks is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `search`:: A query string used to restrict the returned disks. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainContentDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageDomainContentDisksService:%s' % self._path class StorageDomainDiskService(MeasurableService): """ Manages a single disk available in a storage domain. IMPORTANT: Since version 4.2 of the engine this service is intended only to list disks available in the storage domain, and to register unregistered disks. All the other operations, like copying a disk, moving a disk, etc, have been deprecated and will be removed in the future. To perform those operations use the <<services/disks, service that manages all the disks of the system>>, or the <<services/disk, service that manages an specific disk>>. """ def __init__(self, connection, path): super(StorageDomainDiskService, self).__init__(connection, path) self._permissions_service = None self._statistics_service = None def copy( self, disk=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Copies a disk to the specified storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To copy a disk use the <<services/disk/methods/copy, copy>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: Description of the resulting disk. `storage_domain`:: The storage domain where the new disk will be created. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( disk=disk, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait) def export( self, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a disk to an export storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To export a disk use the <<services/disk/methods/export, export>> operation of the service that manages that disk. This method supports the following parameters: `storage_domain`:: The export storage domain where the disk should be exported to. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def move( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Moves a disk to another storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To move a disk use the <<services/disk/methods/move, move>> operation of the service that manages that disk. This method supports the following parameters: `storage_domain`:: The storage domain where the disk will be moved to. `async_`:: Indicates if the move should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait) def reduce( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Reduces the size of the disk image. Invokes _reduce_ on the logical volume (i.e. this is only applicable for block storage domains). This is applicable for floating disks and disks attached to non-running virtual machines. There is no need to specify the size as the optimal size is calculated automatically. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reduce', None, headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes a disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To remove a disk use the <<services/disk/methods/remove, remove>> operation of the service that manages that disk. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def sparsify( self, headers=None, query=None, wait=True, **kwargs ): """ Sparsify the disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To remove a disk use the <<services/disk/methods/remove, remove>> operation of the service that manages that disk. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'sparsify', None, headers, query, wait) def update( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Updates the disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To update a disk use the <<services/disk/methods/update, update>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: The update to apply to the disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(disk, headers, query, wait) def permissions_service(self): """ Reference to the service that manages the permissions assigned to the disk. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageDomainDiskService:%s' % self._path class StorageDomainDisksService(Service): """ Manages the collection of disks available inside a specific storage domain. """ def __init__(self, connection, path): super(StorageDomainDisksService, self).__init__(connection, path) self._disk_service = None def add( self, disk, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Adds or registers a disk. IMPORTANT: Since version 4.2 of the {engine-name} this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To add a new disk use the <<services/disks/methods/add, add>> operation of the service that manages the disks of the system. To register an unregistered disk use the <<services/attached_storage_domain_disk/methods/register, register>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: The disk to add or register. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait) def list( self, follow=None, max=None, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the list of disks that are available in the storage domain. The order of the returned list of disks is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified, all the disks are returned. `unregistered`:: Indicates whether to retrieve a list of registered or unregistered disks in the storage domain. To get a list of unregistered disks in the storage domain the call should indicate the unregistered flag. For example, to get a list of unregistered disks the REST API call should look like this: .... GET /ovirt-engine/api/storagedomains/123/disks?unregistered=true .... The default value of the unregistered flag is `false`. The request only applies to storage domains that are attached. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ A reference to the service that manages a specific disk. """ Service._check_types([ ('id', id, str), ]) return StorageDomainDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageDomainDisksService:%s' % self._path class StorageDomainServerConnectionService(Service): """ """ def __init__(self, connection, path): super(StorageDomainServerConnectionService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Detaches a storage connection from storage. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageDomainServerConnectionService:%s' % self._path class StorageDomainServerConnectionsService(Service): """ Manages the set of connections to storage servers that exist in a storage domain. """ def __init__(self, connection, path): super(StorageDomainServerConnectionsService, self).__init__(connection, path) self._connection_service = None def add( self, connection, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of connections to storage servers that existin the storage domain. The order of the returned list of connections isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of connections to return. If not specified all the connections are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def connection_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainServerConnectionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.connection_service(path) return self.connection_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageDomainServerConnectionsService:%s' % self._path class StorageDomainTemplateService(Service): """ """ def __init__(self, connection, path): super(StorageDomainTemplateService, self).__init__(connection, path) self._disks_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_( self, async_=None, clone=None, cluster=None, exclusive=None, storage_domain=None, template=None, vm=None, headers=None, query=None, wait=True, **kwargs ): """ Action to import a template from an export storage domain. For example, to import the template `456` from the storage domain `123` send the following request: [source] ---- POST /ovirt-engine/api/storagedomains/123/templates/456/import ---- With the following request body: [source, xml] ---- <action> <storage_domain> <name>myexport</name> </storage_domain> <cluster> <name>mycluster</name> </cluster> </action> ---- If you register an entity without specifying the cluster ID or name, the cluster name from the entity's OVF will be used (unless the register request also includes the cluster mapping). This method supports the following parameters: `clone`:: Use the optional `clone` parameter to generate new UUIDs for the imported template and its entities. You can import a template with the `clone` parameter set to `false` when importing a template from an export domain, with templates that were exported by a different {product-name} environment. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('clone', clone, bool), ('cluster', cluster, types.Cluster), ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ('template', template, types.Template), ('vm', vm, types.Vm), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, clone=clone, cluster=cluster, exclusive=exclusive, storage_domain=storage_domain, template=template, vm=vm, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait) def register( self, allow_partial_import=None, async_=None, clone=None, cluster=None, exclusive=None, registration_configuration=None, template=None, vnic_profile_mappings=None, headers=None, query=None, wait=True, **kwargs ): """ Register the Template means importing the Template from the data domain by inserting the configuration of the Template and disks into the database without the copy process. This method supports the following parameters: `allow_partial_import`:: Indicates whether a template is allowed to be registered with only some of its disks. If this flag is `true`, the system will not fail in the validation process if an image is not found, but instead it will allow the template to be registered without the missing disks. This is mainly used during registration of a template when some of the storage domains are not available. The default value is `false`. `vnic_profile_mappings`:: Deprecated attribute describing mapping rules for virtual NIC profiles that will be applied during the import\register process. WARNING: Please note that this attribute has been deprecated since version 4.2.1 of the engine, and preserved only for backward compatibility. It will be removed in the future. To specify `vnic_profile_mappings` use the `vnic_profile_mappings` attribute inside the <<types/registration_configuration, RegistrationConfiguration>> type. `registration_configuration`:: This parameter describes how the template should be registered. This parameter is optional. If the parameter is not specified, the template will be registered with the same configuration that it had in the original environment where it was created. `async_`:: Indicates if the registration should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('allow_partial_import', allow_partial_import, bool), ('async_', async_, bool), ('clone', clone, bool), ('cluster', cluster, types.Cluster), ('exclusive', exclusive, bool), ('registration_configuration', registration_configuration, types.RegistrationConfiguration), ('template', template, types.Template), ('vnic_profile_mappings', vnic_profile_mappings, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( allow_partial_import=allow_partial_import, async_=async_, clone=clone, cluster=cluster, exclusive=exclusive, registration_configuration=registration_configuration, template=template, vnic_profile_mappings=vnic_profile_mappings, ) # Send the request and wait for the response: return self._internal_action(action, 'register', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def disks_service(self): """ """ return StorageDomainContentDisksService(self._connection, '%s/disks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageDomainTemplateService:%s' % self._path class StorageDomainTemplatesService(Service): """ Manages the set of templates available in a storage domain. """ def __init__(self, connection, path): super(StorageDomainTemplatesService, self).__init__(connection, path) self._template_service = None def list( self, follow=None, max=None, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of templates availalbe in the storage domain. The order of the returned list of templates isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of templates to return. If not specified all the templates are returned. `unregistered`:: Indicates whether to retrieve a list of registered or unregistered templates which contain disks on the storage domain. To get a list of unregistered templates the call should indicate the unregistered flag. For example, to get a list of unregistered templates the REST API call should look like this: .... GET /ovirt-engine/api/storagedomains/123/templates?unregistered=true .... The default value of the unregisterd flag is `false`. The request only apply to storage domains that are attached. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_get(headers, query, wait) def template_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainTemplateService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.template_service(path) return self.template_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageDomainTemplatesService:%s' % self._path class StorageDomainVmService(Service): """ """ def __init__(self, connection, path): super(StorageDomainVmService, self).__init__(connection, path) self._disk_attachments_service = None self._disks_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_( self, async_=None, clone=None, cluster=None, collapse_snapshots=None, exclusive=None, storage_domain=None, vm=None, headers=None, query=None, wait=True, **kwargs ): """ Imports a virtual machine from an export storage domain. For example, send a request like this: [source] ---- POST /ovirt-engine/api/storagedomains/123/vms/456/import ---- With a request body like this: [source,xml] ---- <action> <storage_domain> <name>mydata</name> </storage_domain> <cluster> <name>mycluster</name> </cluster> </action> ---- To import a virtual machine as a new entity add the `clone` parameter: [source,xml] ---- <action> <storage_domain> <name>mydata</name> </storage_domain> <cluster> <name>mycluster</name> </cluster> <clone>true</clone> <vm> <name>myvm</name> </vm> </action> ---- Include an optional `disks` parameter to choose which disks to import. For example, to import the disks of the template that have the identifiers `123` and `456` send the following request body: [source,xml] ---- <action> <cluster> <name>mycluster</name> </cluster> <vm> <name>myvm</name> </vm> <disks> <disk id="123"/> <disk id="456"/> </disks> </action> ---- If you register an entity without specifying the cluster ID or name, the cluster name from the entity's OVF will be used (unless the register request also includes the cluster mapping). This method supports the following parameters: `clone`:: Indicates if the identifiers of the imported virtual machine should be regenerated. By default when a virtual machine is imported the identifiers are preserved. This means that the same virtual machine can't be imported multiple times, as that identifiers needs to be unique. To allow importing the same machine multiple times set this parameter to `true`, as the default is `false`. `collapse_snapshots`:: Indicates of the snapshots of the virtual machine that is imported should be collapsed, so that the result will be a virtual machine without snapshots. This parameter is optional, and if it isn't explicitly specified the default value is `false`. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('clone', clone, bool), ('cluster', cluster, types.Cluster), ('collapse_snapshots', collapse_snapshots, bool), ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ('vm', vm, types.Vm), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, clone=clone, cluster=cluster, collapse_snapshots=collapse_snapshots, exclusive=exclusive, storage_domain=storage_domain, vm=vm, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait) def register( self, allow_partial_import=None, async_=None, clone=None, cluster=None, reassign_bad_macs=None, registration_configuration=None, vm=None, vnic_profile_mappings=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `allow_partial_import`:: Indicates whether a virtual machine is allowed to be registered with only some of its disks. If this flag is `true`, the engine will not fail in the validation process if an image is not found, but instead it will allow the virtual machine to be registered without the missing disks. This is mainly used during registration of a virtual machine when some of the storage domains are not available. The default value is `false`. `vnic_profile_mappings`:: Deprecated attribute describing mapping rules for virtual NIC profiles that will be applied during the import\register process. WARNING: Please note that this attribute has been deprecated since version 4.2.1 of the engine, and preserved only for backward compatibility. It will be removed in the future. To specify `vnic_profile_mappings` use the `vnic_profile_mappings` attribute inside the <<types/registration_configuration, RegistrationConfiguration>> type. `reassign_bad_macs`:: Indicates if the problematic MAC addresses should be re-assigned during the import process by the engine. A MAC address would be considered as a problematic one if one of the following is true: - It conflicts with a MAC address that is already allocated to a virtual machine in the target environment. - It's out of the range of the target MAC address pool. `registration_configuration`:: This parameter describes how the virtual machine should be registered. This parameter is optional. If the parameter is not specified, the virtual machine will be registered with the same configuration that it had in the original environment where it was created. `async_`:: Indicates if the registration should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('allow_partial_import', allow_partial_import, bool), ('async_', async_, bool), ('clone', clone, bool), ('cluster', cluster, types.Cluster), ('reassign_bad_macs', reassign_bad_macs, bool), ('registration_configuration', registration_configuration, types.RegistrationConfiguration), ('vm', vm, types.Vm), ('vnic_profile_mappings', vnic_profile_mappings, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( allow_partial_import=allow_partial_import, async_=async_, clone=clone, cluster=cluster, reassign_bad_macs=reassign_bad_macs, registration_configuration=registration_configuration, vm=vm, vnic_profile_mappings=vnic_profile_mappings, ) # Send the request and wait for the response: return self._internal_action(action, 'register', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Deletes a virtual machine from an export storage domain. For example, to delete the virtual machine `456` from the storage domain `123`, send a request like this: [source] ---- DELETE /ovirt-engine/api/storagedomains/123/vms/456 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def disk_attachments_service(self): """ Returns a reference to the service that manages the disk attachments of the virtual machine. """ return StorageDomainVmDiskAttachmentsService(self._connection, '%s/diskattachments' % self._path) def disks_service(self): """ """ return StorageDomainContentDisksService(self._connection, '%s/disks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'diskattachments': return self.disk_attachments_service() if path.startswith('diskattachments/'): return self.disk_attachments_service().service(path[16:]) if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageDomainVmService:%s' % self._path class StorageDomainVmDiskAttachmentService(Service): """ Returns the details of the disks attached to a virtual machine in the export domain. """ def __init__(self, connection, path): super(StorageDomainVmDiskAttachmentService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the details of the attachment with all its properties and a link to the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageDomainVmDiskAttachmentService:%s' % self._path class StorageDomainVmDiskAttachmentsService(Service): """ Returns the details of a disk attached to a virtual machine in the export domain. """ def __init__(self, connection, path): super(StorageDomainVmDiskAttachmentsService, self).__init__(connection, path) self._attachment_service = None def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List the disks that are attached to the virtual machine. The order of the returned list of disk attachments isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def attachment_service(self, id): """ Reference to the service that manages a specific attachment. """ Service._check_types([ ('id', id, str), ]) return StorageDomainVmDiskAttachmentService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.attachment_service(path) return self.attachment_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageDomainVmDiskAttachmentsService:%s' % self._path class StorageDomainVmsService(Service): """ Lists the virtual machines of an export storage domain. For example, to retrieve the virtual machines that are available in the storage domain with identifier `123` send the following request: [source] ---- GET /ovirt-engine/api/storagedomains/123/vms ---- This will return the following response body: [source,xml] ---- <vms> <vm id="456" href="/api/storagedomains/123/vms/456"> <name>vm1</name> ... <storage_domain id="123" href="/api/storagedomains/123"/> <actions> <link rel="import" href="/api/storagedomains/123/vms/456/import"/> </actions> </vm> </vms> ---- Virtual machines and templates in these collections have a similar representation to their counterparts in the top-level <<types/vm, Vm>> and <<types/template, Template>> collections, except they also contain a <<types/storage_domain, StorageDomain>> reference and an <<services/storage_domain_vm/methods/import, import>> action. """ def __init__(self, connection, path): super(StorageDomainVmsService, self).__init__(connection, path) self._vm_service = None def list( self, follow=None, max=None, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of virtual machines of the export storage domain. The order of the returned list of virtual machines isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of virtual machines to return. If not specified all the virtual machines are returned. `unregistered`:: Indicates whether to retrieve a list of registered or unregistered virtual machines which contain disks on the storage domain. To get a list of unregistered virtual machines the call should indicate the unregistered flag. For example, to get a list of unregistered virtual machines the REST API call should look like this: .... GET /ovirt-engine/api/storagedomains/123/vms?unregistered=true .... The default value of the unregisterd flag is `false`. The request only apply to storage domains that are attached. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_get(headers, query, wait) def vm_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainVmService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.vm_service(path) return self.vm_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageDomainVmsService:%s' % self._path class StorageDomainsService(Service): """ Manages the set of storage domains in the system. """ def __init__(self, connection, path): super(StorageDomainsService, self).__init__(connection, path) self._storage_domain_service = None def add( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Adds a new storage domain. Creation of a new <<types/storage_domain,StorageDomain>> requires the `name`, `type`, `host`, and `storage` attributes. Identify the `host` attribute with the `id` or `name` attributes. In {product-name} 3.6 and later you can enable the wipe after delete option by default on the storage domain. To configure this, specify `wipe_after_delete` in the POST request. This option can be edited after the domain is created, but doing so will not change the wipe after delete property of disks that already exist. To add a new storage domain with specified `name`, `type`, `storage.type`, `storage.address`, and `storage.path`, and using a host with an id `123`, send a request like this: [source] ---- POST /ovirt-engine/api/storageDomains ---- With a request body like this: [source,xml] ---- <storage_domain> <name>mydata</name> <type>data</type> <storage> <type>nfs</type> <address>mynfs.example.com</address> <path>/exports/mydata</path> </storage> <host> <name>myhost</name> </host> </storage_domain> ---- To create a new NFS ISO storage domain send a request like this: [source,xml] ---- <storage_domain> <name>myisos</name> <type>iso</type> <storage> <type>nfs</type> <address>mynfs.example.com</address> <path>/export/myisos</path> </storage> <host> <name>myhost</name> </host> </storage_domain> ---- To create a new iSCSI storage domain send a request like this: [source,xml] ---- <storage_domain> <name>myiscsi</name> <type>data</type> <storage> <type>iscsi</type> <logical_units> <logical_unit id="3600144f09dbd050000004eedbd340001"/> <logical_unit id="3600144f09dbd050000004eedbd340002"/> </logical_units> </storage> <host> <name>myhost</name> </host> </storage_domain> ---- This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait) def add_block_domain( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Import an existing block storage domain to the system using the targets already connected to the host. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait) def add_by_path( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Add a new storage domain to the system using the storage on the given host and path. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait) def add_direct_lun( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Add a new storage domain to the system using a direct LUN. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait) def add_gluster_or_postfs( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Add a new storage domain to the system using Gluster or POSIX FS storage. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait) def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of storage domains in the system. The order of the returned list of storage domains is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of storage domains to return. If not specified, all the storage domains are returned. `search`:: A query string used to restrict the returned storage domains. `case_sensitive`:: Indicates if the search should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case, set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def add_local( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Add a new storage domain to the system using the storage on the local host at the given path. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait) def storage_domain_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_domain_service(path) return self.storage_domain_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageDomainsService:%s' % self._path class StorageServerConnectionService(Service): """ """ def __init__(self, connection, path): super(StorageServerConnectionService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def update_glusterfs( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified Glusterfs storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait) def update_iscsi( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified iSCSI storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait) def update_local( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified local storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait) def update_nfs( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified NFS storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait) def remove( self, host=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a storage connection. A storage connection can only be deleted if neither storage domain nor LUN disks reference it. The host name or id is optional; providing it disconnects (unmounts) the connection from that host. This method supports the following parameters: `host`:: The name or identifier of the host from which the connection would be unmounted (disconnected). If not provided, no host will be disconnected. For example, to use the host with identifier `456` to delete the storage connection with identifier `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/storageconnections/123?host=456 ---- `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, str), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if host is not None: query['host'] = host if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the storage connection. For example, to change the address of an NFS storage server, send a request like this: [source,xml] ---- PUT /ovirt-engine/api/storageconnections/123 ---- With a request body like this: [source,xml] ---- <storage_connection> <address>mynewnfs.example.com</address> </storage_connection> ---- To change the connection of an iSCSI storage server, send a request like this: [source,xml] ---- PUT /ovirt-engine/api/storageconnections/123 ---- With a request body like this: [source,xml] ---- <storage_connection> <port>3260</port> <target>iqn.2017-01.com.myhost:444</target> </storage_connection> ---- """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait) def update_vfs( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified VFS storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageServerConnectionService:%s' % self._path class StorageServerConnectionExtensionService(Service): """ """ def __init__(self, connection, path): super(StorageServerConnectionExtensionService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, extension, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update a storage server connection extension for the given host. To update the storage connection `456` of host `123` send a request like this: [source] ---- PUT /ovirt-engine/api/hosts/123/storageconnectionextensions/456 ---- With a request body like this: [source,xml] ---- <storage_connection_extension> <target>iqn.2016-01.com.example:mytarget</target> <username>myuser</username> <password>mypassword</password> </storage_connection_extension> ---- """ # Check the types of the parameters: Service._check_types([ ('extension', extension, types.StorageConnectionExtension), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(extension, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageServerConnectionExtensionService:%s' % self._path class StorageServerConnectionExtensionsService(Service): """ """ def __init__(self, connection, path): super(StorageServerConnectionExtensionsService, self).__init__(connection, path) self._storage_connection_extension_service = None def add( self, extension, headers=None, query=None, wait=True, **kwargs ): """ Creates a new storage server connection extension for the given host. The extension lets the user define credentials for an iSCSI target for a specific host. For example to use `myuser` and `mypassword` as the credentials when connecting to the iSCSI target from host `123` send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/storageconnectionextensions ---- With a request body like this: [source,xml] ---- <storage_connection_extension> <target>iqn.2016-01.com.example:mytarget</target> <username>myuser</username> <password>mypassword</password> </storage_connection_extension> ---- """ # Check the types of the parameters: Service._check_types([ ('extension', extension, types.StorageConnectionExtension), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(extension, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list os storage connection extensions. The order of the returned list of storage connections isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of extensions to return. If not specified all the extensions are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def storage_connection_extension_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageServerConnectionExtensionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_connection_extension_service(path) return self.storage_connection_extension_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageServerConnectionExtensionsService:%s' % self._path class StorageServerConnectionsService(Service): """ """ def __init__(self, connection, path): super(StorageServerConnectionsService, self).__init__(connection, path) self._storage_connection_service = None def add( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Creates a new storage connection. For example, to create a new storage connection for the NFS server `mynfs.example.com` and NFS share `/export/mydata` send a request like this: [source] ---- POST /ovirt-engine/api/storageconnections ---- With a request body like this: [source,xml] ---- <storage_connection> <type>nfs</type> <address>mynfs.example.com</address> <path>/export/mydata</path> <host> <name>myhost</name> </host> </storage_connection> ---- """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait) def add_glusterfs( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a Glusterfs storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait) def add_iscsi( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a iSCSI storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of storage connections. The order of the returned list of connections isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of connections to return. If not specified all the connections are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def add_local( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a local storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait) def add_nfs( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a nfs storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait) def add_vfs( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a vfs storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait) def storage_connection_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageServerConnectionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_connection_service(path) return self.storage_connection_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageServerConnectionsService:%s' % self._path class SystemService(Service): """ """ def __init__(self, connection, path): super(SystemService, self).__init__(connection, path) self._affinity_labels_service = None self._bookmarks_service = None self._cluster_levels_service = None self._clusters_service = None self._cpu_profiles_service = None self._data_centers_service = None self._disk_profiles_service = None self._disks_service = None self._domains_service = None self._events_service = None self._external_host_providers_service = None self._external_template_imports_service = None self._external_vm_imports_service = None self._groups_service = None self._hosts_service = None self._icons_service = None self._image_transfers_service = None self._instance_types_service = None self._jobs_service = None self._katello_errata_service = None self._mac_pools_service = None self._network_filters_service = None self._networks_service = None self._openstack_image_providers_service = None self._openstack_network_providers_service = None self._openstack_volume_providers_service = None self._operating_systems_service = None self._options_service = None self._permissions_service = None self._roles_service = None self._scheduling_policies_service = None self._scheduling_policy_units_service = None self._storage_connections_service = None self._storage_domains_service = None self._tags_service = None self._templates_service = None self._users_service = None self._vm_pools_service = None self._vms_service = None self._vnic_profiles_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns basic information describing the API, like the product name, the version number and a summary of the number of relevant objects. [source] ---- GET /ovirt-engine/api ---- We get following response: [source,xml] ---- <api> <link rel="capabilities" href="/api/capabilities"/> <link rel="clusters" href="/api/clusters"/> <link rel="clusters/search" href="/api/clusters?search={query}"/> <link rel="datacenters" href="/api/datacenters"/> <link rel="datacenters/search" href="/api/datacenters?search={query}"/> <link rel="events" href="/api/events"/> <link rel="events/search" href="/api/events?search={query}"/> <link rel="hosts" href="/api/hosts"/> <link rel="hosts/search" href="/api/hosts?search={query}"/> <link rel="networks" href="/api/networks"/> <link rel="roles" href="/api/roles"/> <link rel="storagedomains" href="/api/storagedomains"/> <link rel="storagedomains/search" href="/api/storagedomains?search={query}"/> <link rel="tags" href="/api/tags"/> <link rel="templates" href="/api/templates"/> <link rel="templates/search" href="/api/templates?search={query}"/> <link rel="users" href="/api/users"/> <link rel="groups" href="/api/groups"/> <link rel="domains" href="/api/domains"/> <link rel="vmpools" href="/api/vmpools"/> <link rel="vmpools/search" href="/api/vmpools?search={query}"/> <link rel="vms" href="/api/vms"/> <link rel="vms/search" href="/api/vms?search={query}"/> <product_info> <name>oVirt Engine</name> <vendor>ovirt.org</vendor> <version> <build>4</build> <full_version>4.0.4</full_version> <major>4</major> <minor>0</minor> <revision>0</revision> </version> </product_info> <special_objects> <blank_template href="/ovirt-engine/api/templates/00000000-0000-0000-0000-000000000000" id="00000000-0000-0000-0000-000000000000"/> <root_tag href="/ovirt-engine/api/tags/00000000-0000-0000-0000-000000000000" id="00000000-0000-0000-0000-000000000000"/> </special_objects> <summary> <hosts> <active>0</active> <total>0</total> </hosts> <storage_domains> <active>0</active> <total>1</total> </storage_domains> <users> <active>1</active> <total>1</total> </users> <vms> <active>0</active> <total>0</total> </vms> </summary> <time>2016-09-14T12:00:48.132+02:00</time> </api> ---- The entry point provides a user with links to the collections in a virtualization environment. The `rel` attribute of each collection link provides a reference point for each link. The entry point also contains other data such as `product_info`, `special_objects` and `summary`. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def reload_configurations( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the reload should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reloadconfigurations', None, headers, query, wait) def affinity_labels_service(self): """ List all known affinity labels. """ return AffinityLabelsService(self._connection, '%s/affinitylabels' % self._path) def bookmarks_service(self): """ """ return BookmarksService(self._connection, '%s/bookmarks' % self._path) def cluster_levels_service(self): """ Reference to the service that provides information about the cluster levels supported by the system. """ return ClusterLevelsService(self._connection, '%s/clusterlevels' % self._path) def clusters_service(self): """ """ return ClustersService(self._connection, '%s/clusters' % self._path) def cpu_profiles_service(self): """ """ return CpuProfilesService(self._connection, '%s/cpuprofiles' % self._path) def data_centers_service(self): """ """ return DataCentersService(self._connection, '%s/datacenters' % self._path) def disk_profiles_service(self): """ """ return DiskProfilesService(self._connection, '%s/diskprofiles' % self._path) def disks_service(self): """ """ return DisksService(self._connection, '%s/disks' % self._path) def domains_service(self): """ """ return DomainsService(self._connection, '%s/domains' % self._path) def events_service(self): """ """ return EventsService(self._connection, '%s/events' % self._path) def external_host_providers_service(self): """ """ return ExternalHostProvidersService(self._connection, '%s/externalhostproviders' % self._path) def external_template_imports_service(self): """ Reference to service facilitating import of external templates. """ return ExternalTemplateImportsService(self._connection, '%s/externaltemplateimports' % self._path) def external_vm_imports_service(self): """ Reference to service facilitating import of external virtual machines. """ return ExternalVmImportsService(self._connection, '%s/externalvmimports' % self._path) def groups_service(self): """ """ return GroupsService(self._connection, '%s/groups' % self._path) def hosts_service(self): """ """ return HostsService(self._connection, '%s/hosts' % self._path) def icons_service(self): """ """ return IconsService(self._connection, '%s/icons' % self._path) def image_transfers_service(self): """ List of all image transfers being performed for image I/O in oVirt. """ return ImageTransfersService(self._connection, '%s/imagetransfers' % self._path) def instance_types_service(self): """ """ return InstanceTypesService(self._connection, '%s/instancetypes' % self._path) def jobs_service(self): """ List all the jobs monitored by the engine. """ return JobsService(self._connection, '%s/jobs' % self._path) def katello_errata_service(self): """ List the available Katello errata assigned to the engine. """ return EngineKatelloErrataService(self._connection, '%s/katelloerrata' % self._path) def mac_pools_service(self): """ """ return MacPoolsService(self._connection, '%s/macpools' % self._path) def network_filters_service(self): """ Network filters will enhance the admin ability to manage the network packets traffic from/to the participated VMs. """ return NetworkFiltersService(self._connection, '%s/networkfilters' % self._path) def networks_service(self): """ """ return NetworksService(self._connection, '%s/networks' % self._path) def openstack_image_providers_service(self): """ """ return OpenstackImageProvidersService(self._connection, '%s/openstackimageproviders' % self._path) def openstack_network_providers_service(self): """ """ return OpenstackNetworkProvidersService(self._connection, '%s/openstacknetworkproviders' % self._path) def openstack_volume_providers_service(self): """ """ return OpenstackVolumeProvidersService(self._connection, '%s/openstackvolumeproviders' % self._path) def operating_systems_service(self): """ """ return OperatingSystemsService(self._connection, '%s/operatingsystems' % self._path) def options_service(self): """ Reference to the service that provides values of configuration options of the system. """ return SystemOptionsService(self._connection, '%s/options' % self._path) def permissions_service(self): """ """ return SystemPermissionsService(self._connection, '%s/permissions' % self._path) def roles_service(self): """ """ return RolesService(self._connection, '%s/roles' % self._path) def scheduling_policies_service(self): """ """ return SchedulingPoliciesService(self._connection, '%s/schedulingpolicies' % self._path) def scheduling_policy_units_service(self): """ """ return SchedulingPolicyUnitsService(self._connection, '%s/schedulingpolicyunits' % self._path) def storage_connections_service(self): """ """ return StorageServerConnectionsService(self._connection, '%s/storageconnections' % self._path) def storage_domains_service(self): """ """ return StorageDomainsService(self._connection, '%s/storagedomains' % self._path) def tags_service(self): """ """ return TagsService(self._connection, '%s/tags' % self._path) def templates_service(self): """ """ return TemplatesService(self._connection, '%s/templates' % self._path) def users_service(self): """ """ return UsersService(self._connection, '%s/users' % self._path) def vm_pools_service(self): """ """ return VmPoolsService(self._connection, '%s/vmpools' % self._path) def vms_service(self): """ """ return VmsService(self._connection, '%s/vms' % self._path) def vnic_profiles_service(self): """ """ return VnicProfilesService(self._connection, '%s/vnicprofiles' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'affinitylabels': return self.affinity_labels_service() if path.startswith('affinitylabels/'): return self.affinity_labels_service().service(path[15:]) if path == 'bookmarks': return self.bookmarks_service() if path.startswith('bookmarks/'): return self.bookmarks_service().service(path[10:]) if path == 'clusterlevels': return self.cluster_levels_service() if path.startswith('clusterlevels/'): return self.cluster_levels_service().service(path[14:]) if path == 'clusters': return self.clusters_service() if path.startswith('clusters/'): return self.clusters_service().service(path[9:]) if path == 'cpuprofiles': return self.cpu_profiles_service() if path.startswith('cpuprofiles/'): return self.cpu_profiles_service().service(path[12:]) if path == 'datacenters': return self.data_centers_service() if path.startswith('datacenters/'): return self.data_centers_service().service(path[12:]) if path == 'diskprofiles': return self.disk_profiles_service() if path.startswith('diskprofiles/'): return self.disk_profiles_service().service(path[13:]) if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) if path == 'domains': return self.domains_service() if path.startswith('domains/'): return self.domains_service().service(path[8:]) if path == 'events': return self.events_service() if path.startswith('events/'): return self.events_service().service(path[7:]) if path == 'externalhostproviders': return self.external_host_providers_service() if path.startswith('externalhostproviders/'): return self.external_host_providers_service().service(path[22:]) if path == 'externaltemplateimports': return self.external_template_imports_service() if path.startswith('externaltemplateimports/'): return self.external_template_imports_service().service(path[24:]) if path == 'externalvmimports': return self.external_vm_imports_service() if path.startswith('externalvmimports/'): return self.external_vm_imports_service().service(path[18:]) if path == 'groups': return self.groups_service() if path.startswith('groups/'): return self.groups_service().service(path[7:]) if path == 'hosts': return self.hosts_service() if path.startswith('hosts/'): return self.hosts_service().service(path[6:]) if path == 'icons': return self.icons_service() if path.startswith('icons/'): return self.icons_service().service(path[6:]) if path == 'imagetransfers': return self.image_transfers_service() if path.startswith('imagetransfers/'): return self.image_transfers_service().service(path[15:]) if path == 'instancetypes': return self.instance_types_service() if path.startswith('instancetypes/'): return self.instance_types_service().service(path[14:]) if path == 'jobs': return self.jobs_service() if path.startswith('jobs/'): return self.jobs_service().service(path[5:]) if path == 'katelloerrata': return self.katello_errata_service() if path.startswith('katelloerrata/'): return self.katello_errata_service().service(path[14:]) if path == 'macpools': return self.mac_pools_service() if path.startswith('macpools/'): return self.mac_pools_service().service(path[9:]) if path == 'networkfilters': return self.network_filters_service() if path.startswith('networkfilters/'): return self.network_filters_service().service(path[15:]) if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) if path == 'openstackimageproviders': return self.openstack_image_providers_service() if path.startswith('openstackimageproviders/'): return self.openstack_image_providers_service().service(path[24:]) if path == 'openstacknetworkproviders': return self.openstack_network_providers_service() if path.startswith('openstacknetworkproviders/'): return self.openstack_network_providers_service().service(path[26:]) if path == 'openstackvolumeproviders': return self.openstack_volume_providers_service() if path.startswith('openstackvolumeproviders/'): return self.openstack_volume_providers_service().service(path[25:]) if path == 'operatingsystems': return self.operating_systems_service() if path.startswith('operatingsystems/'): return self.operating_systems_service().service(path[17:]) if path == 'options': return self.options_service() if path.startswith('options/'): return self.options_service().service(path[8:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'roles': return self.roles_service() if path.startswith('roles/'): return self.roles_service().service(path[6:]) if path == 'schedulingpolicies': return self.scheduling_policies_service() if path.startswith('schedulingpolicies/'): return self.scheduling_policies_service().service(path[19:]) if path == 'schedulingpolicyunits': return self.scheduling_policy_units_service() if path.startswith('schedulingpolicyunits/'): return self.scheduling_policy_units_service().service(path[22:]) if path == 'storageconnections': return self.storage_connections_service() if path.startswith('storageconnections/'): return self.storage_connections_service().service(path[19:]) if path == 'storagedomains': return self.storage_domains_service() if path.startswith('storagedomains/'): return self.storage_domains_service().service(path[15:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) if path == 'templates': return self.templates_service() if path.startswith('templates/'): return self.templates_service().service(path[10:]) if path == 'users': return self.users_service() if path.startswith('users/'): return self.users_service().service(path[6:]) if path == 'vmpools': return self.vm_pools_service() if path.startswith('vmpools/'): return self.vm_pools_service().service(path[8:]) if path == 'vms': return self.vms_service() if path.startswith('vms/'): return self.vms_service().service(path[4:]) if path == 'vnicprofiles': return self.vnic_profiles_service() if path.startswith('vnicprofiles/'): return self.vnic_profiles_service().service(path[13:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SystemService:%s' % self._path class SystemOptionService(Service): """ A service that provides values of specific configuration option of the system. """ def __init__(self, connection, path): super(SystemOptionService, self).__init__(connection, path) def get( self, version=None, headers=None, query=None, wait=True, **kwargs ): """ Get the values of specific configuration option. For example to retrieve the values of configuration option `MigrationPoliciesSupported` send a request like this: [source] ---- GET /ovirt-engine/api/options/MigrationPoliciesSupported ---- The response to that request will be the following: [source,xml] ---- <system_option href="/ovirt-engine/api/options/MigrationPoliciesSupported" id="MigrationPoliciesSupported"> <name>MigrationPoliciesSupported</name> <values> <system_option_value> <value>true</value> <version>4.0</version> </system_option_value> <system_option_value> <value>true</value> <version>4.1</version> </system_option_value> <system_option_value> <value>true</value> <version>4.2</version> </system_option_value> <system_option_value> <value>false</value> <version>3.6</version> </system_option_value> </values> </system_option> ---- NOTE: The appropriate permissions are required to query configuration options. Some options can be queried only by users with administrator permissions. [IMPORTANT] ==== There is NO backward compatibility and no guarantee about the names or values of the options. Options may be removed and their meaning can be changed at any point. We strongly discourage the use of this service for applications other than the ones that are released simultaneously with the engine. Usage by other applications is not supported. Therefore there will be no documentation listing accessible configuration options. ==== This method supports the following parameters: `version`:: Optional version parameter that specifies that only particular version of the configuration option should be returned. If this parameter isn't used then all the versions will be returned. For example, to get the value of the `MigrationPoliciesSupported` option but only for version `4.2` send a request like this: [source] ---- GET /ovirt-engine/api/options/MigrationPoliciesSupported?version=4.2 ---- The response to that request will be like this: [source,xml] ---- <system_option href="/ovirt-engine/api/options/MigrationPoliciesSupported" id="MigrationPoliciesSupported"> <name>MigrationPoliciesSupported</name> <values> <system_option_value> <value>true</value> <version>4.2</version> </system_option_value> </values> </system_option> ---- `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('version', version, str), ]) # Build the URL: query = query or {} if version is not None: query['version'] = version # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SystemOptionService:%s' % self._path class SystemOptionsService(Service): """ Service that provides values of configuration options of the system. """ def __init__(self, connection, path): super(SystemOptionsService, self).__init__(connection, path) self._option_service = None def option_service(self, id): """ Returns a reference to the service that provides values of specific configuration option. """ Service._check_types([ ('id', id, str), ]) return SystemOptionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.option_service(path) return self.option_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SystemOptionsService:%s' % self._path class SystemPermissionsService(AssignedPermissionsService): """ This service doesn't add any new methods, it is just a placeholder for the annotation that specifies the path of the resource that manages the permissions assigned to the system object. """ def __init__(self, connection, path): super(SystemPermissionsService, self).__init__(connection, path) self._permission_service = None def add( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Assign a new permission to a user or group for specific entity. For example, to assign the `UserVmManager` role to the virtual machine with id `123` to the user with id `456` send a request like this: .... POST /ovirt-engine/api/vms/123/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>UserVmManager</name> </role> <user id="456"/> </permission> ---- To assign the `SuperUser` role to the system to the user with id `456` send a request like this: .... POST /ovirt-engine/api/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>SuperUser</name> </role> <user id="456"/> </permission> ---- If you want to assign permission to the group instead of the user please replace the `user` element with the `group` element with proper `id` of the group. For example to assign the `UserRole` role to the cluster with id `123` to the group with id `789` send a request like this: .... POST /ovirt-engine/api/clusters/123/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>UserRole</name> </role> <group id="789"/> </permission> ---- This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_cluster_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the cluster to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_data_center_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the data center to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_group_level( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new group level permission for a given virtual machine. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_host_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the host to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List all the permissions of the specific entity. For example to list all the permissions of the cluster with id `123` send a request like this: .... GET /ovirt-engine/api/clusters/123/permissions .... [source,xml] ---- <permissions> <permission id="456"> <cluster id="123"/> <role id="789"/> <user id="451"/> </permission> <permission id="654"> <cluster id="123"/> <role id="789"/> <group id="127"/> </permission> </permissions> ---- The order of the returned permissions isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def add_storage_domain_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the storage domain to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_template_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the template to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_user_level( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new user level permission for a given virtual machine. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_vm_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the vm to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_vm_pool_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the vm pool to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def permission_service(self, id): """ Sub-resource locator method, returns individual permission resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return PermissionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.permission_service(path) return self.permission_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SystemPermissionsService:%s' % self._path class TagService(Service): """ A service to manage a specific tag in the system. """ def __init__(self, connection, path): super(TagService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the information about the tag. For example to retrieve the information about the tag with the id `123` send a request like this: .... GET /ovirt-engine/api/tags/123 .... [source,xml] ---- <tag href="/ovirt-engine/api/tags/123" id="123"> <name>root</name> <description>root</description> </tag> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the tag from the system. For example to remove the tag with id `123` send a request like this: .... DELETE /ovirt-engine/api/tags/123 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, tag, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the tag entity. For example to update parent tag to tag with id `456` of the tag with id `123` send a request like this: .... PUT /ovirt-engine/api/tags/123 .... With request body like: [source,xml] ---- <tag> <parent id="456"/> </tag> ---- You may also specify a tag name instead of id. For example to update parent tag to tag with name `mytag` of the tag with id `123` send a request like this: [source,xml] ---- <tag> <parent> <name>mytag</name> </parent> </tag> ---- This method supports the following parameters: `tag`:: The updated tag. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('tag', tag, types.Tag), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(tag, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TagService:%s' % self._path class TagsService(Service): """ Represents a service to manage collection of the tags in the system. """ def __init__(self, connection, path): super(TagsService, self).__init__(connection, path) self._tag_service = None def add( self, tag, headers=None, query=None, wait=True, **kwargs ): """ Add a new tag to the system. For example, to add new tag with name `mytag` to the system send a request like this: .... POST /ovirt-engine/api/tags .... With a request body like this: [source,xml] ---- <tag> <name>mytag</name> </tag> ---- NOTE: The root tag is a special pseudo-tag assumed as the default parent tag if no parent tag is specified. The root tag cannot be deleted nor assigned a parent tag. To create new tag with specific parent tag send a request body like this: [source,xml] ---- <tag> <name>mytag</name> <parent> <name>myparenttag</name> </parent> </tag> ---- This method supports the following parameters: `tag`:: The added tag. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('tag', tag, types.Tag), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(tag, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the tags in the system. For example to list the full hierarchy of the tags in the system send a request like this: .... GET /ovirt-engine/api/tags .... [source,xml] ---- <tags> <tag href="/ovirt-engine/api/tags/222" id="222"> <name>root2</name> <description>root2</description> <parent href="/ovirt-engine/api/tags/111" id="111"/> </tag> <tag href="/ovirt-engine/api/tags/333" id="333"> <name>root3</name> <description>root3</description> <parent href="/ovirt-engine/api/tags/222" id="222"/> </tag> <tag href="/ovirt-engine/api/tags/111" id="111"> <name>root</name> <description>root</description> </tag> </tags> ---- In the previous XML output you can see the following hierarchy of the tags: .... root: (id: 111) - root2 (id: 222) - root3 (id: 333) .... The order of the returned list of tags isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of tags to return. If not specified all the tags are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def tag_service(self, id): """ Reference to the service that manages a specific tag. """ Service._check_types([ ('id', id, str), ]) return TagService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.tag_service(path) return self.tag_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TagsService:%s' % self._path class TemplateService(Service): """ Manages the virtual machine template and template versions. """ def __init__(self, connection, path): super(TemplateService, self).__init__(connection, path) self._cdroms_service = None self._disk_attachments_service = None self._graphics_consoles_service = None self._nics_service = None self._permissions_service = None self._tags_service = None self._watchdogs_service = None def export( self, exclusive=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a template to the data center export domain. For example, send the following request: [source] ---- POST /ovirt-engine/api/templates/123/export ---- With a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> <exclusive>true<exclusive/> </action> ---- This method supports the following parameters: `exclusive`:: Indicates if the existing templates with the same name should be overwritten. The export action reports a failed action if a template of the same name exists in the destination domain. Set this parameter to `true` to change this behavior and overwrite any existing template. `storage_domain`:: Specifies the destination export storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( exclusive=exclusive, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about this template or template version. This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a virtual machine template. [source] ---- DELETE /ovirt-engine/api/templates/123 ---- This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def export_to_export_domain( self, exclusive=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a template to an export domain. This method supports the following parameters: `exclusive`:: Indicates if the existing templates with the same name should be overwritten. The export action reports a failed action if a template of the same name exists in the destination domain. Set this parameter to `true` to change this behavior and overwrite any existing template. `storage_domain`:: Specifies the destination export storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( exclusive=exclusive, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def export_to_path_on_host( self, directory=None, exclusive=None, filename=None, host=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a template as an OVA file to a given path on a specified host. This method supports the following parameters: `host`:: The host to generate the OVA file on. `directory`:: An absolute path of a directory on the host to generate the OVA file in. `filename`:: The name of the OVA file. This is an optional parameter. If it is not specified, the name of the OVA file is determined according to the name of the template. It will conform to the following pattern: "<template name>.ova". `exclusive`:: Indicates if the existing templates with the same name should be overwritten. The export action reports a failed action if a template of the same name exists in the destination domain. Set this parameter to `true` to change this behavior and overwrite any existing template. `storage_domain`:: Specifies the destination export storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('directory', directory, str), ('exclusive', exclusive, bool), ('filename', filename, str), ('host', host, types.Host), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( directory=directory, exclusive=exclusive, filename=filename, host=host, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def update( self, template, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the template. The `name`, `description`, `type`, `memory`, `cpu`, `topology`, `os`, `high_availability`, `display`, `stateless`, `usb`, and `timezone` elements can be updated after a template has been created. For example, to update a template so that it has 1 GiB of memory send a request like this: [source] ---- PUT /ovirt-engine/api/templates/123 ---- With the following request body: [source,xml] ---- <template> <memory>1073741824</memory> </template> ---- The `version_name` name attribute is the only one that can be updated within the `version` attribute used for template versions: [source,xml] ---- <template> <version> <version_name>mytemplate_2</version_name> </version> </template> ---- """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(template, headers, query, wait) def cdroms_service(self): """ Returns a reference to the service that manages the CD-ROMs that are associated with the template. """ return TemplateCdromsService(self._connection, '%s/cdroms' % self._path) def disk_attachments_service(self): """ Returns a reference to the service that manages a specific disk attachment of the template. """ return TemplateDiskAttachmentsService(self._connection, '%s/diskattachments' % self._path) def graphics_consoles_service(self): """ Returns a reference to the service that manages the graphical consoles that are associated with the template. """ return TemplateGraphicsConsolesService(self._connection, '%s/graphicsconsoles' % self._path) def nics_service(self): """ Returns a reference to the service that manages the NICs that are associated with the template. """ return TemplateNicsService(self._connection, '%s/nics' % self._path) def permissions_service(self): """ Returns a reference to the service that manages the permissions that are associated with the template. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def tags_service(self): """ Returns a reference to the service that manages the tags that are associated with the template. """ return AssignedTagsService(self._connection, '%s/tags' % self._path) def watchdogs_service(self): """ Returns a reference to the service that manages the _watchdogs_ that are associated with the template. """ return TemplateWatchdogsService(self._connection, '%s/watchdogs' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'cdroms': return self.cdroms_service() if path.startswith('cdroms/'): return self.cdroms_service().service(path[7:]) if path == 'diskattachments': return self.disk_attachments_service() if path.startswith('diskattachments/'): return self.disk_attachments_service().service(path[16:]) if path == 'graphicsconsoles': return self.graphics_consoles_service() if path.startswith('graphicsconsoles/'): return self.graphics_consoles_service().service(path[17:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) if path == 'watchdogs': return self.watchdogs_service() if path.startswith('watchdogs/'): return self.watchdogs_service().service(path[10:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TemplateService:%s' % self._path class TemplateCdromService(Service): """ A service managing a CD-ROM device on templates. """ def __init__(self, connection, path): super(TemplateCdromService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about this CD-ROM device. For example, to get information about the CD-ROM device of template `123` send a request like: [source] ---- GET /ovirt-engine/api/templates/123/cdroms/ ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TemplateCdromService:%s' % self._path class TemplateCdromsService(Service): """ Lists the CD-ROM devices of a template. """ def __init__(self, connection, path): super(TemplateCdromsService, self).__init__(connection, path) self._cdrom_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of CD-ROM devices of the template. The order of the returned list of CD-ROM devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of CD-ROMs to return. If not specified all the CD-ROMs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def cdrom_service(self, id): """ Returns a reference to the service that manages a specific CD-ROM device. """ Service._check_types([ ('id', id, str), ]) return TemplateCdromService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.cdrom_service(path) return self.cdrom_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TemplateCdromsService:%s' % self._path class TemplateDiskService(Service): """ """ def __init__(self, connection, path): super(TemplateDiskService, self).__init__(connection, path) def copy( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Copy the specified disk attached to the template to a specific storage domain. This method supports the following parameters: `async_`:: Indicates if the copy should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait) def export( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the export should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TemplateDiskService:%s' % self._path class TemplateDiskAttachmentService(Service): """ This service manages the attachment of a disk to a template. """ def __init__(self, connection, path): super(TemplateDiskAttachmentService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the details of the attachment. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, storage_domain=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the disk from the template. The disk will only be removed if there are other existing copies of the disk on other storage domains. A storage domain has to be specified to determine which of the copies should be removed (template disks can have copies on multiple storage domains). [source] ---- DELETE /ovirt-engine/api/templates/{template:id}/diskattachments/{attachment:id}?storage_domain=072fbaa1-08f3-4a40-9f34-a5ca22dd1d74 ---- This method supports the following parameters: `storage_domain`:: Specifies the identifier of the storage domain the image to be removed resides on. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, str), ('force', force, bool), ]) # Build the URL: query = query or {} if storage_domain is not None: query['storage_domain'] = storage_domain if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TemplateDiskAttachmentService:%s' % self._path class TemplateDiskAttachmentsService(Service): """ This service manages the set of disks attached to a template. Each attached disk is represented by a <<types/disk_attachment,DiskAttachment>>. """ def __init__(self, connection, path): super(TemplateDiskAttachmentsService, self).__init__(connection, path) self._attachment_service = None def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List the disks that are attached to the template. The order of the returned list of attachments isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def attachment_service(self, id): """ Reference to the service that manages a specific attachment. """ Service._check_types([ ('id', id, str), ]) return TemplateDiskAttachmentService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.attachment_service(path) return self.attachment_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TemplateDiskAttachmentsService:%s' % self._path class TemplateDisksService(Service): """ """ def __init__(self, connection, path): super(TemplateDisksService, self).__init__(connection, path) self._disk_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks of the template. The order of the returned list of disks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return TemplateDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TemplateDisksService:%s' % self._path class TemplateGraphicsConsoleService(Service): """ """ def __init__(self, connection, path): super(TemplateGraphicsConsoleService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets graphics console configuration of the template. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the graphics console from the template. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TemplateGraphicsConsoleService:%s' % self._path class TemplateGraphicsConsolesService(Service): """ """ def __init__(self, connection, path): super(TemplateGraphicsConsolesService, self).__init__(connection, path) self._console_service = None def add( self, console, headers=None, query=None, wait=True, **kwargs ): """ Add new graphics console to the template. """ # Check the types of the parameters: Service._check_types([ ('console', console, types.GraphicsConsole), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(console, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured graphics consoles of the template. The order of the returned list of graphics consoles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of consoles to return. If not specified all the consoles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def console_service(self, id): """ Returns a reference to the service that manages a specific template graphics console. """ Service._check_types([ ('id', id, str), ]) return TemplateGraphicsConsoleService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.console_service(path) return self.console_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TemplateGraphicsConsolesService:%s' % self._path class TemplateNicService(Service): """ """ def __init__(self, connection, path): super(TemplateNicService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, nic, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified network interface card attached to the template. """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(nic, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TemplateNicService:%s' % self._path class TemplateNicsService(Service): """ """ def __init__(self, connection, path): super(TemplateNicsService, self).__init__(connection, path) self._nic_service = None def add( self, nic, headers=None, query=None, wait=True, **kwargs ): """ Add a new network interface card to the template. """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(nic, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of NICs of the template. The order of the returned list of NICs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def nic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return TemplateNicService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TemplateNicsService:%s' % self._path class TemplateWatchdogService(Service): """ """ def __init__(self, connection, path): super(TemplateWatchdogService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, watchdog, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the watchdog for the template identified by the given id. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(watchdog, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TemplateWatchdogService:%s' % self._path class TemplateWatchdogsService(Service): """ """ def __init__(self, connection, path): super(TemplateWatchdogsService, self).__init__(connection, path) self._watchdog_service = None def add( self, watchdog, headers=None, query=None, wait=True, **kwargs ): """ Add a watchdog to the template identified by the given id. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(watchdog, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of watchdogs. The order of the returned list of watchdogs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of watchdogs to return. If not specified all the watchdogs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def watchdog_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return TemplateWatchdogService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.watchdog_service(path) return self.watchdog_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TemplateWatchdogsService:%s' % self._path class TemplatesService(Service): """ This service manages the virtual machine templates available in the system. """ def __init__(self, connection, path): super(TemplatesService, self).__init__(connection, path) self._template_service = None def add( self, template, clone_permissions=None, seal=None, headers=None, query=None, wait=True, **kwargs ): """ Creates a new template. This requires the `name` and `vm` elements. To identify the virtual machine use the `vm.id` or `vm.name` attributes. For example, to create a template from a virtual machine with the identifier `123` send a request like this: [source] ---- POST /ovirt-engine/api/templates ---- With a request body like this: [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"/> </template> ---- Since version 4.3, in order to create virtual machine template from a snapshot send a request body like this: [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"> <snapshots> <snapshot id="456"/> </snapshots> </vm> </template> ---- The disks of the template can be customized, making some of their characteristics different from the disks of the original virtual machine. To do so use the `vm.disk_attachments` attribute, specifying the identifier of the disk of the original virtual machine and the characteristics that you want to change. For example, if the original virtual machine has a disk with the identifier `456`, and, for that disk, you want to change the name to `mydisk` the format to <<types/disk_format, _Copy On Write_>> and make it <<types/disk, sparse>>, send a request body like this: [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"> <disk_attachments> <disk_attachment> <disk id="456"> <name>mydisk</name> <format>cow</format> <sparse>true</sparse> </disk> </disk_attachment> </disk_attachments> </vm> </template> ---- The template can be created as a sub-version of an existing template. This requires the `name` and `vm` attributes for the new template, and the `base_template` and `version_name` attributes for the new template version. The `base_template` and `version_name` attributes must be specified within a `version` section enclosed in the `template` section. Identify the virtual machine with the `id` or `name` attributes. [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"/> <version> <base_template id="456"/> <version_name>mytemplate_001</version_name> </version> </template> ---- The destination storage domain of the template can be customized, in one of two ways: 1. Globally, at the request level. The request must list the desired disk attachments to be created on the storage domain. If the disk attachments are not listed, the global storage domain parameter will be ignored. + [source,xml] ---- <template> <name>mytemplate</name> <storage_domain id="123"/> <vm id="456"> <disk_attachments> <disk_attachment> <disk id="789"> <format>cow</format> <sparse>true</sparse> </disk> </disk_attachment> </disk_attachments> </vm> </template> ---- 2. Per each disk attachment. Specify the desired storage domain for each disk attachment. Specifying the global storage definition will override the storage domain per disk attachment specification. + [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"> <disk_attachments> <disk_attachment> <disk id="456"> <format>cow</format> <sparse>true</sparse> <storage_domains> <storage_domain id="789"/> </storage_domains> </disk> </disk_attachment> </disk_attachments> </vm> </template> ---- This method supports the following parameters: `template`:: The information about the template or template version. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('clone_permissions', clone_permissions, bool), ('seal', seal, bool), ]) # Build the URL: query = query or {} if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if seal is not None: seal = Writer.render_boolean(seal) query['seal'] = seal # Send the request and wait for the response: return self._internal_add(template, headers, query, wait) def add_from_configuration( self, template, clone_permissions=None, seal=None, headers=None, query=None, wait=True, **kwargs ): """ Add a virtual machine template to the system from a configuration. Requires the configuration type, the configuration data, and the target cluster. This method supports the following parameters: `template`:: The information about the template or template version. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('clone_permissions', clone_permissions, bool), ('seal', seal, bool), ]) # Build the URL: query = query or {} if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if seal is not None: seal = Writer.render_boolean(seal) query['seal'] = seal # Send the request and wait for the response: return self._internal_add(template, headers, query, wait) def add_from_vm( self, template, clone_permissions=None, seal=None, headers=None, query=None, wait=True, **kwargs ): """ Add a virtual machine template to the system from an existing virtual machine. This method supports the following parameters: `template`:: The information about the template or template version. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('clone_permissions', clone_permissions, bool), ('seal', seal, bool), ]) # Build the URL: query = query or {} if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if seal is not None: seal = Writer.render_boolean(seal) query['seal'] = seal # Send the request and wait for the response: return self._internal_add(template, headers, query, wait) def add_from_vm_snapshot( self, template, clone_permissions=None, seal=None, headers=None, query=None, wait=True, **kwargs ): """ Add a virtual machine template to the system from a snapshot. This method supports the following parameters: `template`:: The information about the template or template version. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('clone_permissions', clone_permissions, bool), ('seal', seal, bool), ]) # Build the URL: query = query or {} if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if seal is not None: seal = Writer.render_boolean(seal) query['seal'] = seal # Send the request and wait for the response: return self._internal_add(template, headers, query, wait) def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of virtual machine templates. For example: [source] ---- GET /ovirt-engine/api/templates ---- Will return the list of virtual machines and virtual machine templates. The order of the returned list of templates is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of templates to return. If not specified, all the templates are returned. `search`:: A query string used to restrict the returned templates. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def template_service(self, id): """ Returns a reference to the service that manages a specific virtual machine template. """ Service._check_types([ ('id', id, str), ]) return TemplateService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.template_service(path) return self.template_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TemplatesService:%s' % self._path class UnmanagedNetworkService(Service): """ """ def __init__(self, connection, path): super(UnmanagedNetworkService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'UnmanagedNetworkService:%s' % self._path class UnmanagedNetworksService(Service): """ """ def __init__(self, connection, path): super(UnmanagedNetworksService, self).__init__(connection, path) self._unmanaged_network_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of unmanaged networks of the host. The order of the returned list of networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def unmanaged_network_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return UnmanagedNetworkService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.unmanaged_network_service(path) return self.unmanaged_network_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'UnmanagedNetworksService:%s' % self._path class UserService(Service): """ A service to manage a user in the system. Use this service to either get users details or remove users. In order to add new users please use <<services/users>>. """ def __init__(self, connection, path): super(UserService, self).__init__(connection, path) self._event_subscriptions_service = None self._groups_service = None self._options_service = None self._permissions_service = None self._roles_service = None self._ssh_public_keys_service = None self._tags_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the system user information. Usage: .... GET /ovirt-engine/api/users/1234 .... Will return the user information: [source,xml] ---- <user href="/ovirt-engine/api/users/1234" id="1234"> <name>admin</name> <link href="/ovirt-engine/api/users/1234/sshpublickeys" rel="sshpublickeys"/> <link href="/ovirt-engine/api/users/1234/roles" rel="roles"/> <link href="/ovirt-engine/api/users/1234/permissions" rel="permissions"/> <link href="/ovirt-engine/api/users/1234/tags" rel="tags"/> <department></department> <domain_entry_id>23456</domain_entry_id> <email>user1@domain.com</email> <last_name>Lastname</last_name> <namespace>*</namespace> <principal>user1</principal> <user_name>user1@domain-authz</user_name> <domain href="/ovirt-engine/api/domains/45678" id="45678"> <name>domain-authz</name> </domain> </user> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the system user. Usage: .... DELETE /ovirt-engine/api/users/1234 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, user, headers=None, query=None, wait=True, **kwargs ): """ Updates information about the user. Only the `user_options` field can be updated. For example, to update user options: [source] ---- PUT /ovirt-engine/api/users/123 ---- With a request body like this: [source,xml] ---- <user> <user_options> <property> <name>test</name> <value>["any","JSON"]</value> </property> </user_options> </user> ---- IMPORTANT: Since version 4.4.5 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. Please use the <<services/user_option, options>> endpoint instead. """ # Check the types of the parameters: Service._check_types([ ('user', user, types.User), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(user, headers, query, wait) def event_subscriptions_service(self): """ List of event-subscriptions for this user. """ return EventSubscriptionsService(self._connection, '%s/eventsubscriptions' % self._path) def groups_service(self): """ """ return DomainUserGroupsService(self._connection, '%s/groups' % self._path) def options_service(self): """ """ return UserOptionsService(self._connection, '%s/options' % self._path) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def roles_service(self): """ """ return AssignedRolesService(self._connection, '%s/roles' % self._path) def ssh_public_keys_service(self): """ """ return SshPublicKeysService(self._connection, '%s/sshpublickeys' % self._path) def tags_service(self): """ """ return AssignedTagsService(self._connection, '%s/tags' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'eventsubscriptions': return self.event_subscriptions_service() if path.startswith('eventsubscriptions/'): return self.event_subscriptions_service().service(path[19:]) if path == 'groups': return self.groups_service() if path.startswith('groups/'): return self.groups_service().service(path[7:]) if path == 'options': return self.options_service() if path.startswith('options/'): return self.options_service().service(path[8:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'roles': return self.roles_service() if path.startswith('roles/'): return self.roles_service().service(path[6:]) if path == 'sshpublickeys': return self.ssh_public_keys_service() if path.startswith('sshpublickeys/'): return self.ssh_public_keys_service().service(path[14:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'UserService:%s' % self._path class UserOptionService(Service): """ """ def __init__(self, connection, path): super(UserOptionService, self).__init__(connection, path) def get( self, headers=None, query=None, wait=True, **kwargs ): """ Returns a user profile property of type JSON. Example request(for user with identifier `123` and option with identifier `456`): [source] ---- GET /ovirt-engine/api/users/123/options/456 ---- The result will be the following XML document: [source,xml] ---- <user_option href="/ovirt-engine/api/users/123/options/456" id="456"> <name>SomeName</name> <content>["any", "JSON"]</content> <user href="/ovirt-engine/api/users/123" id="123"/> </user_option> ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Deletes an existing property of type JSON. Example request(for user with identifier `123` and option with identifier `456`): [source] ---- DELETE /ovirt-engine/api/users/123/options/456 ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'UserOptionService:%s' % self._path class UserOptionsService(Service): """ """ def __init__(self, connection, path): super(UserOptionsService, self).__init__(connection, path) self._option_service = None def add( self, option, headers=None, query=None, wait=True, **kwargs ): """ Adds a new user profile property of type JSON. Example request(for user with identifier `123`): [source] ---- POST /ovirt-engine/api/users/123/options ---- Payload: [source,xml] ---- <user_option> <name>SomeName</name> <content>["any", "JSON"]</content> </user_option> ---- """ # Check the types of the parameters: Service._check_types([ ('option', option, types.UserOption), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(option, headers, query, wait) def list( self, headers=None, query=None, wait=True, **kwargs ): """ Returns a list of user profile properties of type JSON. Example request(for user with identifier `123`): [source] ---- GET /ovirt-engine/api/users/123/options ---- The result will be the following XML document: [source,xml] ---- <user_options> <user_option href="/ovirt-engine/api/users/123/options/456" id="456"> <name>SomeName</name> <content>["any", "JSON"]</content> <user href="/ovirt-engine/api/users/123" id="123"/> </user_option> </user_options> ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_get(headers, query, wait) def option_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return UserOptionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.option_service(path) return self.option_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'UserOptionsService:%s' % self._path class UsersService(Service): """ A service to manage the users in the system. """ def __init__(self, connection, path): super(UsersService, self).__init__(connection, path) self._user_service = None def add( self, user, headers=None, query=None, wait=True, **kwargs ): """ Add user from a directory service. For example, to add the `myuser` user from the `myextension-authz` authorization provider send a request like this: [source] ---- POST /ovirt-engine/api/users ---- With a request body like this: [source,xml] ---- <user> <user_name>myuser@myextension-authz</user_name> <domain> <name>myextension-authz</name> </domain> </user> ---- In case you are working with Active Directory you have to pass user principal name (UPN) as `username`, followed by authorization provider name. Due to https://bugzilla.redhat.com/1147900[bug 1147900] you need to provide also `principal` parameter set to UPN of the user. For example, to add the user with UPN `myuser@mysubdomain.mydomain.com` from the `myextension-authz` authorization provider send a request body like this: [source,xml] ---- <user> <principal>myuser@mysubdomain.mydomain.com</principal> <user_name>myuser@mysubdomain.mydomain.com@myextension-authz</user_name> <domain> <name>myextension-authz</name> </domain> </user> ---- """ # Check the types of the parameters: Service._check_types([ ('user', user, types.User), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(user, headers, query, wait) def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ List all the users in the system. Usage: .... GET /ovirt-engine/api/users .... Will return the list of users: [source,xml] ---- <users> <user href="/ovirt-engine/api/users/1234" id="1234"> <name>admin</name> <link href="/ovirt-engine/api/users/1234/sshpublickeys" rel="sshpublickeys"/> <link href="/ovirt-engine/api/users/1234/roles" rel="roles"/> <link href="/ovirt-engine/api/users/1234/permissions" rel="permissions"/> <link href="/ovirt-engine/api/users/1234/tags" rel="tags"/> <domain_entry_id>23456</domain_entry_id> <namespace>*</namespace> <principal>user1</principal> <user_name>user1@domain-authz</user_name> <domain href="/ovirt-engine/api/domains/45678" id="45678"> <name>domain-authz</name> </domain> </user> </users> ---- The order of the returned list of users isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of users to return. If not specified all the users are returned. `search`:: A query string used to restrict the returned users. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def user_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return UserService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.user_service(path) return self.user_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'UsersService:%s' % self._path class VirtualFunctionAllowedNetworkService(Service): """ """ def __init__(self, connection, path): super(VirtualFunctionAllowedNetworkService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VirtualFunctionAllowedNetworkService:%s' % self._path class VirtualFunctionAllowedNetworksService(Service): """ """ def __init__(self, connection, path): super(VirtualFunctionAllowedNetworksService, self).__init__(connection, path) self._network_service = None def add( self, network, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(network, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of networks. The order of the returned list of networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def network_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VirtualFunctionAllowedNetworkService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VirtualFunctionAllowedNetworksService:%s' % self._path class VmService(MeasurableService): """ """ def __init__(self, connection, path): super(VmService, self).__init__(connection, path) self._affinity_labels_service = None self._applications_service = None self._backups_service = None self._cdroms_service = None self._checkpoints_service = None self._disk_attachments_service = None self._graphics_consoles_service = None self._host_devices_service = None self._katello_errata_service = None self._nics_service = None self._numa_nodes_service = None self._permissions_service = None self._reported_devices_service = None self._sessions_service = None self._snapshots_service = None self._statistics_service = None self._tags_service = None self._watchdogs_service = None def auto_pin_cpu_and_numa_nodes( self, async_=None, optimize_cpu_settings=None, headers=None, query=None, wait=True, **kwargs ): """ Apply an automatic CPU and NUMA configuration on the VM. An example for a request: [source] ---- POST /ovirt-engine/api/vms/123/autopincpuandnumanodes ---- With a request body like this: [source,xml] ---- <action> <optimize_cpu_settings>true</optimize_cpu_settings> </action> ---- This method supports the following parameters: `optimize_cpu_settings`:: Specifies how the auto CPU and NUMA configuration is applied. If set to true, will adjust the CPU topology to fit the VM pinned host hardware. Otherwise, it will use the VM CPU topology. `async_`:: Indicates if the detach action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('optimize_cpu_settings', optimize_cpu_settings, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, optimize_cpu_settings=optimize_cpu_settings, ) # Send the request and wait for the response: return self._internal_action(action, 'autopincpuandnumanodes', None, headers, query, wait) def cancel_migration( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation stops any migration of a virtual machine to another physical host. [source] ---- POST /ovirt-engine/api/vms/123/cancelmigration ---- The cancel migration action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the migration should cancelled asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'cancelmigration', None, headers, query, wait) def clone( self, async_=None, discard_snapshots=None, storage_domain=None, vm=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the clone should be performed asynchronously. `discard_snapshots`:: Use the `discard_snapshots` parameter when the virtual machine should be clone with its snapshots collapsed. Default is true. `storage_domain`:: The storage domain on which the virtual machines disks will be copied to. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('discard_snapshots', discard_snapshots, bool), ('storage_domain', storage_domain, types.StorageDomain), ('vm', vm, types.Vm), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, discard_snapshots=discard_snapshots, storage_domain=storage_domain, vm=vm, ) # Send the request and wait for the response: return self._internal_action(action, 'clone', None, headers, query, wait) def commit_snapshot( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Permanently restores the virtual machine to the state of the previewed snapshot. See the <<services/vm/methods/preview_snapshot, preview_snapshot>> operation for details. This method supports the following parameters: `async_`:: Indicates if the snapshots should be committed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'commitsnapshot', None, headers, query, wait) def detach( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Detaches a virtual machine from a pool. [source] ---- POST /ovirt-engine/api/vms/123/detach ---- The detach action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the detach action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'detach', None, headers, query, wait) def export( self, async_=None, discard_snapshots=None, exclusive=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports the virtual machine. A virtual machine can be exported to an export domain. For example, to export virtual machine `123` to the export domain `myexport`: [source] ---- POST /ovirt-engine/api/vms/123/export ---- With a request body like this: [source,xml] ---- <action> <storage_domain> <name>myexport</name> </storage_domain> <exclusive>true</exclusive> <discard_snapshots>true</discard_snapshots> </action> ---- Since version 4.2 of the engine it is also possible to export a virtual machine as a virtual appliance (OVA). For example, to export virtual machine `123` as an OVA file named `myvm.ova` that is placed in the directory `/home/ovirt/` on host `myhost`: [source] ---- POST /ovirt-engine/api/vms/123/export ---- With a request body like this: [source,xml] ---- <action> <host> <name>myhost</name> </host> <directory>/home/ovirt</directory> <filename>myvm.ova</filename> </action> ---- NOTE: Confirm that the export operation has completed before attempting any actions on the export domain. This method supports the following parameters: `discard_snapshots`:: Use the `discard_snapshots` parameter when the virtual machine should be exported with all of its snapshots collapsed. `exclusive`:: Use the `exclusive` parameter when the virtual machine should be exported even if another copy of it already exists in the export domain (override). `storage_domain`:: The (export) storage domain to export the virtual machine to. `async_`:: Indicates if the export should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('discard_snapshots', discard_snapshots, bool), ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, discard_snapshots=discard_snapshots, exclusive=exclusive, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def freeze_filesystems( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Freezes virtual machine file systems. This operation freezes a virtual machine's file systems using the QEMU guest agent when taking a live snapshot of a running virtual machine. Normally, this is done automatically by the manager, but this must be executed manually with the API for virtual machines using OpenStack Volume (Cinder) disks. Example: [source] ---- POST /ovirt-engine/api/vms/123/freezefilesystems ---- [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the freeze should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'freezefilesystems', None, headers, query, wait) def get( self, all_content=None, filter=None, follow=None, next_run=None, ovf_as_ova=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the virtual machine. This method supports the following parameters: `next_run`:: Indicates if the returned result describes the virtual machine as it is currently running or if describes the virtual machine with the modifications that have already been performed but that will only come into effect when the virtual machine is restarted. By default the value is `false`. If the parameter is included in the request, but without a value, it is assumed that the value is `true`. The the following request: [source] ---- GET /vms/{vm:id};next_run ---- Is equivalent to using the value `true`: [source] ---- GET /vms/{vm:id};next_run=true ---- `all_content`:: Indicates if all of the attributes of the virtual machine should be included in the response. By default the following attributes are excluded: - `console` - `initialization.configuration.data` - The OVF document describing the virtual machine. - `rng_source` - `soundcard` - `virtio_scsi` For example, to retrieve the complete representation of the virtual machine '123': .... GET /ovirt-engine/api/vms/123?all_content=true .... NOTE: These attributes are not included by default as they reduce performance. These attributes are seldom used and require additional queries to the database. Only use this parameter when required as it will reduce performance. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `ovf_as_ova`:: Indicates if the results should expose the OVF as it appears in OVA files of that VM. The OVF document describing the virtual machine. This parameter will work only when all_content=True is set. The OVF will be presented in `initialization.configuration.data`. For example: [source] ---- GET /vms/{vm:id}?all_content=true&ovf_as_ova=true ---- `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('filter', filter, bool), ('follow', follow, str), ('next_run', next_run, bool), ('ovf_as_ova', ovf_as_ova, bool), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if next_run is not None: next_run = Writer.render_boolean(next_run) query['next_run'] = next_run if ovf_as_ova is not None: ovf_as_ova = Writer.render_boolean(ovf_as_ova) query['ovf_as_ova'] = ovf_as_ova # Send the request and wait for the response: return self._internal_get(headers, query, wait) def logon( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Initiates the automatic user logon to access a virtual machine from an external console. This action requires the `ovirt-guest-agent-gdm-plugin` and the `ovirt-guest-agent-pam-module` packages to be installed and the `ovirt-guest-agent` service to be running on the virtual machine. Users require the appropriate user permissions for the virtual machine in order to access the virtual machine from an external console. For example: [source] ---- POST /ovirt-engine/api/vms/123/logon ---- Request body: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the logon should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'logon', None, headers, query, wait) def maintenance( self, async_=None, maintenance_enabled=None, headers=None, query=None, wait=True, **kwargs ): """ Sets the global maintenance mode on the hosted engine virtual machine. This action has no effect on other virtual machines. Example: [source] ---- POST /ovirt-engine/api/vms/123/maintenance ---- [source,xml] ---- <action> <maintenance_enabled>true<maintenance_enabled/> </action> ---- This method supports the following parameters: `maintenance_enabled`:: Indicates if global maintenance should be enabled or disabled. `async_`:: Indicates if the global maintenance action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('maintenance_enabled', maintenance_enabled, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, maintenance_enabled=maintenance_enabled, ) # Send the request and wait for the response: return self._internal_action(action, 'maintenance', None, headers, query, wait) def migrate( self, async_=None, cluster=None, force=None, host=None, migrate_vms_in_affinity_closure=None, headers=None, query=None, wait=True, **kwargs ): """ Migrates a virtual machine to another physical host. Example: [source] ---- POST /ovirt-engine/api/vms/123/migrate ---- To specify a specific host to migrate the virtual machine to: [source,xml] ---- <action> <host id="2ab5e1da-b726-4274-bbf7-0a42b16a0fc3"/> </action> ---- This method supports the following parameters: `cluster`:: Specifies the cluster the virtual machine should migrate to. This is an optional parameter. By default, the virtual machine is migrated to another host within the same cluster. WARNING: Live migration to another cluster is not supported. Strongly consider the target cluster's hardware architecture and network architecture before attempting a migration. `force`:: Specifies that the virtual machine should migrate even if the virtual machine is defined as non-migratable. This is an optional parameter. By default, it is set to `false`. `host`:: Specifies a specific host that the virtual machine should migrate to. This is an optional parameter. By default, the {engine-name} automatically selects a default host for migration within the same cluster. If an API user requires a specific host, the user can specify the host with either an `id` or `name` parameter. `migrate_vms_in_affinity_closure`:: Migrate also all other virtual machines in positive enforcing affinity groups with this virtual machine, that are running on the same host. The default value is `false`. `async_`:: Indicates if the migration should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('force', force, bool), ('host', host, types.Host), ('migrate_vms_in_affinity_closure', migrate_vms_in_affinity_closure, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, cluster=cluster, force=force, host=host, migrate_vms_in_affinity_closure=migrate_vms_in_affinity_closure, ) # Send the request and wait for the response: return self._internal_action(action, 'migrate', None, headers, query, wait) def preview_snapshot( self, async_=None, disks=None, lease=None, restore_memory=None, snapshot=None, vm=None, headers=None, query=None, wait=True, **kwargs ): """ Temporarily restores the virtual machine to the state of a snapshot. The snapshot is indicated with the `snapshot.id` parameter. It is restored temporarily, so that the content can be inspected. Once that inspection is finished, the state of the virtual machine can be made permanent, using the <<services/vm/methods/commit_snapshot, commit_snapshot>> method, or discarded using the <<services/vm/methods/undo_snapshot, undo_snapshot>> method. This method supports the following parameters: `disks`:: Specify the disks included in the snapshot's preview. For each disk parameter, it is also required to specify its `image_id`. For example, to preview a snapshot with identifier `456` which includes a disk with identifier `111` and its `image_id` as `222`, send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/previewsnapshot ---- Request body: [source,xml] ---- <action> <disks> <disk id="111"> <image_id>222</image_id> </disk> </disks> <snapshot id="456"/> </action> ---- `lease`:: Specify the lease storage domain ID to use in the preview of the snapshot. If lease parameter is not passed, then the previewed snapshot lease storage domain will be used. If lease parameter is passed with empty storage domain parameter, then no lease will be used for the snapshot preview. If lease parameter is passed with storage domain parameter then the storage domain ID can be only one of the leases domain IDs that belongs to one of the virtual machine snapshots. This is an optional parameter, set by default to `null` `async_`:: Indicates if the preview should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('disks', disks, list), ('lease', lease, types.StorageDomainLease), ('restore_memory', restore_memory, bool), ('snapshot', snapshot, types.Snapshot), ('vm', vm, types.Vm), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, disks=disks, lease=lease, restore_memory=restore_memory, snapshot=snapshot, vm=vm, ) # Send the request and wait for the response: return self._internal_action(action, 'previewsnapshot', None, headers, query, wait) def reboot( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Sends a reboot request to a virtual machine. For example: [source] ---- POST /ovirt-engine/api/vms/123/reboot ---- The reboot action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- To reboot the VM even if a backup is running for it, the action should include the 'force' element. For example, to force reboot virtual machine `123`: ---- POST /ovirt-engine/api/vms/123/reboot ---- [source,xml] ---- <action> <force>true</force> </action> ---- This method supports the following parameters: `force`:: Indicates if the VM should be forcibly rebooted even if a backup is running for it. `async_`:: Indicates if the reboot should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'reboot', None, headers, query, wait) def remove( self, async_=None, detach_only=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the virtual machine, including the virtual disks attached to it. For example, to remove the virtual machine with identifier `123`: [source] ---- DELETE /ovirt-engine/api/vms/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `detach_only`:: Indicates if the attached virtual disks should be detached first and preserved instead of being removed. `force`:: Indicates if the virtual machine should be forcibly removed. Locked virtual machines and virtual machines with locked disk images cannot be removed without this flag set to true. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('detach_only', detach_only, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if detach_only is not None: detach_only = Writer.render_boolean(detach_only) query['detach_only'] = detach_only if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: self._internal_remove(headers, query, wait) def reorder_mac_addresses( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reordermacaddresses', None, headers, query, wait) def reset( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Sends a reset request to a virtual machine. For example: [source] ---- POST /ovirt-engine/api/vms/123/reset ---- The reset action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the reset should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reset', None, headers, query, wait) def shutdown( self, async_=None, force=None, reason=None, headers=None, query=None, wait=True, **kwargs ): """ This operation sends a shutdown request to a virtual machine. For example: [source] ---- POST /ovirt-engine/api/vms/123/shutdown ---- The shutdown action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- To shutdown the VM even if a backup is running for it, the action should include the 'force' element. For example, to force shutdown virtual machine `123`: ---- POST /ovirt-engine/api/vms/123/shutdown ---- [source,xml] ---- <action> <force>true</force> </action> ---- This method supports the following parameters: `force`:: Indicates if the VM should be forcibly shutdown even if a backup is running for it. `async_`:: Indicates if the shutdown should be performed asynchronously. `reason`:: The reason the virtual machine was stopped. Optionally set by user when shutting down the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('reason', reason, str), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, reason=reason, ) # Send the request and wait for the response: return self._internal_action(action, 'shutdown', None, headers, query, wait) def start( self, async_=None, authorized_key=None, filter=None, pause=None, use_cloud_init=None, use_ignition=None, use_initialization=None, use_sysprep=None, vm=None, volatile=None, headers=None, query=None, wait=True, **kwargs ): """ Starts the virtual machine. If the virtual environment is complete and the virtual machine contains all necessary components to function, it can be started. This example starts the virtual machine: [source] ---- POST /ovirt-engine/api/vms/123/start ---- With a request body: [source,xml] ---- <action/> ---- This method supports the following parameters: `pause`:: If set to `true`, start the virtual machine in paused mode. The default is `false`. `vm`:: The definition of the virtual machine for this specific run. For example: [source,xml] ---- <action> <vm> <os> <boot> <devices> <device>cdrom</device> </devices> </boot> </os> </vm> </action> ---- This will set the boot device to the CDROM only for this specific start. After the virtual machine is powered off, this definition will be reverted. `use_cloud_init`:: If set to `true`, the initialization type is set to _cloud-init_. The default value is `false`. See https://cloudinit.readthedocs.io/en/latest[this] for details. `use_sysprep`:: If set to `true`, the initialization type is set to _Sysprep_. The default value is `false`. See https://en.wikipedia.org/wiki/Sysprep[this] for details. `use_ignition`:: If set to `true`, the initialization type is set to _Ignition_. The default value is `false`. See https://coreos.com/ignition/docs/latest/[this] for details. `use_initialization`:: If set to `true`, the initialization type is set by the VM's OS. Windows will set to _Sysprep_, Linux to _cloud-init_ and RedHat CoreOS to _Ignition_. If any of the initialization-types are explicitly set (useCloudInit, useSysprep or useIgnition), they will be prioritized and this flag will be ignored. The default value is `false`. `async_`:: Indicates if the start action should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `volatile`:: Indicates that this run configuration will be discarded even in the case of guest-initiated reboot. The default value is `false`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('authorized_key', authorized_key, types.AuthorizedKey), ('filter', filter, bool), ('pause', pause, bool), ('use_cloud_init', use_cloud_init, bool), ('use_ignition', use_ignition, bool), ('use_initialization', use_initialization, bool), ('use_sysprep', use_sysprep, bool), ('vm', vm, types.Vm), ('volatile', volatile, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, authorized_key=authorized_key, filter=filter, pause=pause, use_cloud_init=use_cloud_init, use_ignition=use_ignition, use_initialization=use_initialization, use_sysprep=use_sysprep, vm=vm, volatile=volatile, ) # Send the request and wait for the response: return self._internal_action(action, 'start', None, headers, query, wait) def stop( self, async_=None, force=None, reason=None, headers=None, query=None, wait=True, **kwargs ): """ This operation forces a virtual machine to power-off. For example: [source] ---- POST /ovirt-engine/api/vms/123/stop ---- The stop action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- To stop the VM even if a backup is running for it, the action should include the 'force' element. For example, to force stop virtual machine `123`: ---- POST /ovirt-engine/api/vms/123/stop ---- [source,xml] ---- <action> <force>true</force> </action> ---- This method supports the following parameters: `force`:: Indicates if the VM should be forcibly stop even if a backup is running for it. `async_`:: Indicates if the stop action should be performed asynchronously. `reason`:: The reason the virtual machine was stopped. Optionally set by user when shutting down the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('reason', reason, str), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, reason=reason, ) # Send the request and wait for the response: return self._internal_action(action, 'stop', None, headers, query, wait) def suspend( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation saves the virtual machine state to disk and stops it. Start a suspended virtual machine and restore the virtual machine state with the start action. For example: [source] ---- POST /ovirt-engine/api/vms/123/suspend ---- The suspend action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the suspend action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'suspend', None, headers, query, wait) def thaw_filesystems( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Thaws virtual machine file systems. This operation thaws a virtual machine's file systems using the QEMU guest agent when taking a live snapshot of a running virtual machine. Normally, this is done automatically by the manager, but this must be executed manually with the API for virtual machines using OpenStack Volume (Cinder) disks. Example: [source] ---- POST /api/vms/123/thawfilesystems ---- [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the thaw file systems action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'thawfilesystems', None, headers, query, wait) def ticket( self, async_=None, ticket=None, headers=None, query=None, wait=True, **kwargs ): """ Generates a time-sensitive authentication token for accessing a virtual machine's display. For example: [source] ---- POST /ovirt-engine/api/vms/123/ticket ---- The client-provided action optionally includes a desired ticket value and/or an expiry time in seconds. The response specifies the actual ticket value and expiry used. [source,xml] ---- <action> <ticket> <value>abcd12345</value> <expiry>120</expiry> </ticket> </action> ---- [IMPORTANT] ==== If the virtual machine is configured to support only one graphics protocol then the generated authentication token will be valid for that protocol. But if the virtual machine is configured to support multiple protocols, VNC and SPICE, then the authentication token will only be valid for the SPICE protocol. In order to obtain an authentication token for a specific protocol, for example for VNC, use the `ticket` method of the <<services/vm_graphics_console, service>>, which manages the graphics consoles of the virtual machine, by sending a request: [source] ---- POST /ovirt-engine/api/vms/123/graphicsconsoles/456/ticket ---- ==== This method supports the following parameters: `async_`:: Indicates if the generation of the ticket should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('ticket', ticket, types.Ticket), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ticket=ticket, ) # Send the request and wait for the response: return self._internal_action(action, 'ticket', 'ticket', headers, query, wait) def export_to_export_domain( self, async_=None, discard_snapshots=None, exclusive=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a virtual machine to an export domain. This method supports the following parameters: `discard_snapshots`:: Use the `discard_snapshots` parameter when the virtual machine should be exported with all of its snapshots collapsed. `exclusive`:: Use the `exclusive` parameter when the virtual machine should be exported even if another copy of it already exists in the export domain (override). `storage_domain`:: The (export) storage domain to export the virtual machine to. `async_`:: Indicates if the export should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('discard_snapshots', discard_snapshots, bool), ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, discard_snapshots=discard_snapshots, exclusive=exclusive, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def export_to_path_on_host( self, async_=None, directory=None, discard_snapshots=None, exclusive=None, filename=None, host=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a virtual machine as an OVA file to a given path on a specified host. This method supports the following parameters: `host`:: The host to generate the OVA file on. `directory`:: An absolute path of a directory on the host to generate the OVA file in. `filename`:: The name of the OVA file. This is an optional parameter, if it is not specified then the name of OVA file is determined according to the name of the virtual machine. It will conform the following pattern: "<virtual machine name>.ova". `discard_snapshots`:: Use the `discard_snapshots` parameter when the virtual machine should be exported with all of its snapshots collapsed. `exclusive`:: Use the `exclusive` parameter when the virtual machine should be exported even if another copy of it already exists in the export domain (override). `storage_domain`:: The (export) storage domain to export the virtual machine to. `async_`:: Indicates if the export should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('directory', directory, str), ('discard_snapshots', discard_snapshots, bool), ('exclusive', exclusive, bool), ('filename', filename, str), ('host', host, types.Host), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, directory=directory, discard_snapshots=discard_snapshots, exclusive=exclusive, filename=filename, host=host, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def undo_snapshot( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Restores the virtual machine to the state it had before previewing the snapshot. See the <<services/vm/methods/preview_snapshot, preview_snapshot>> operation for details. This method supports the following parameters: `async_`:: Indicates if the undo snapshot action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'undosnapshot', None, headers, query, wait) def update( self, vm, async_=None, next_run=None, headers=None, query=None, wait=True, **kwargs ): """ Update the virtual machine in the system for the given virtual machine id. """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('async_', async_, bool), ('next_run', next_run, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if next_run is not None: next_run = Writer.render_boolean(next_run) query['next_run'] = next_run # Send the request and wait for the response: return self._internal_update(vm, headers, query, wait) def affinity_labels_service(self): """ List of scheduling labels assigned to this virtual machine. """ return AssignedAffinityLabelsService(self._connection, '%s/affinitylabels' % self._path) def applications_service(self): """ """ return VmApplicationsService(self._connection, '%s/applications' % self._path) def backups_service(self): """ List of backups of this virtual machine. """ return VmBackupsService(self._connection, '%s/backups' % self._path) def cdroms_service(self): """ """ return VmCdromsService(self._connection, '%s/cdroms' % self._path) def checkpoints_service(self): """ List of checkpoints of this virtual machine. """ return VmCheckpointsService(self._connection, '%s/checkpoints' % self._path) def disk_attachments_service(self): """ List of disks attached to this virtual machine. """ return DiskAttachmentsService(self._connection, '%s/diskattachments' % self._path) def graphics_consoles_service(self): """ """ return VmGraphicsConsolesService(self._connection, '%s/graphicsconsoles' % self._path) def host_devices_service(self): """ """ return VmHostDevicesService(self._connection, '%s/hostdevices' % self._path) def katello_errata_service(self): """ Reference to the service that can show the applicable errata available on the virtual machine. This information is taken from Katello. """ return KatelloErrataService(self._connection, '%s/katelloerrata' % self._path) def nics_service(self): """ """ return VmNicsService(self._connection, '%s/nics' % self._path) def numa_nodes_service(self): """ """ return VmNumaNodesService(self._connection, '%s/numanodes' % self._path) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def reported_devices_service(self): """ """ return VmReportedDevicesService(self._connection, '%s/reporteddevices' % self._path) def sessions_service(self): """ Reference to the service that provides information about virtual machine user sessions. """ return VmSessionsService(self._connection, '%s/sessions' % self._path) def snapshots_service(self): """ """ return SnapshotsService(self._connection, '%s/snapshots' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def tags_service(self): """ """ return AssignedTagsService(self._connection, '%s/tags' % self._path) def watchdogs_service(self): """ """ return VmWatchdogsService(self._connection, '%s/watchdogs' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'affinitylabels': return self.affinity_labels_service() if path.startswith('affinitylabels/'): return self.affinity_labels_service().service(path[15:]) if path == 'applications': return self.applications_service() if path.startswith('applications/'): return self.applications_service().service(path[13:]) if path == 'backups': return self.backups_service() if path.startswith('backups/'): return self.backups_service().service(path[8:]) if path == 'cdroms': return self.cdroms_service() if path.startswith('cdroms/'): return self.cdroms_service().service(path[7:]) if path == 'checkpoints': return self.checkpoints_service() if path.startswith('checkpoints/'): return self.checkpoints_service().service(path[12:]) if path == 'diskattachments': return self.disk_attachments_service() if path.startswith('diskattachments/'): return self.disk_attachments_service().service(path[16:]) if path == 'graphicsconsoles': return self.graphics_consoles_service() if path.startswith('graphicsconsoles/'): return self.graphics_consoles_service().service(path[17:]) if path == 'hostdevices': return self.host_devices_service() if path.startswith('hostdevices/'): return self.host_devices_service().service(path[12:]) if path == 'katelloerrata': return self.katello_errata_service() if path.startswith('katelloerrata/'): return self.katello_errata_service().service(path[14:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) if path == 'numanodes': return self.numa_nodes_service() if path.startswith('numanodes/'): return self.numa_nodes_service().service(path[10:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'reporteddevices': return self.reported_devices_service() if path.startswith('reporteddevices/'): return self.reported_devices_service().service(path[16:]) if path == 'sessions': return self.sessions_service() if path.startswith('sessions/'): return self.sessions_service().service(path[9:]) if path == 'snapshots': return self.snapshots_service() if path.startswith('snapshots/'): return self.snapshots_service().service(path[10:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) if path == 'watchdogs': return self.watchdogs_service() if path.startswith('watchdogs/'): return self.watchdogs_service().service(path[10:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmService:%s' % self._path class VmApplicationService(Service): """ A service that provides information about an application installed in a virtual machine. """ def __init__(self, connection, path): super(VmApplicationService, self).__init__(connection, path) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about the application. This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmApplicationService:%s' % self._path class VmApplicationsService(Service): """ A service that provides information about applications installed in a virtual machine. """ def __init__(self, connection, path): super(VmApplicationsService, self).__init__(connection, path) self._application_service = None def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns a list of applications installed in the virtual machine. The order of the returned list of applications isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of applications to return. If not specified all the applications are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def application_service(self, id): """ Returns a reference to the service that provides information about a specific application. """ Service._check_types([ ('id', id, str), ]) return VmApplicationService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.application_service(path) return self.application_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmApplicationsService:%s' % self._path class VmBackupService(Service): """ A service managing a backup of a virtual machines. """ def __init__(self, connection, path): super(VmBackupService, self).__init__(connection, path) self._disks_service = None def finalize( self, headers=None, query=None, wait=True, **kwargs ): """ Finalize the virtual machine backup entity. End backup, unlock resources, and perform cleanups. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'finalize', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns information about the virtual machine backup. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disks_service(self): """ A reference to the service that lists the disks in backup. """ return VmBackupDisksService(self._connection, '%s/disks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmBackupService:%s' % self._path class VmBackupDiskService(Service): """ """ def __init__(self, connection, path): super(VmBackupDiskService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmBackupDiskService:%s' % self._path class VmBackupDisksService(Service): """ """ def __init__(self, connection, path): super(VmBackupDisksService, self).__init__(connection, path) self._disk_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks in backup. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified, all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ A reference to the service that manages a specific disk. """ Service._check_types([ ('id', id, str), ]) return VmBackupDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmBackupDisksService:%s' % self._path class VmBackupsService(Service): """ Lists the backups of a virtual machine. """ def __init__(self, connection, path): super(VmBackupsService, self).__init__(connection, path) self._backup_service = None def add( self, backup, require_consistency=None, headers=None, query=None, wait=True, **kwargs ): """ Adds a new backup entity to a virtual machine. For example, to start a new incremental backup of a virtual machine since checkpoint id `previous-checkpoint-uuid`, send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/backups ---- With a request body like this: [source,xml] ---- <backup> <from_checkpoint_id>previous-checkpoint-uuid</from_checkpoint_id> <disks> <disk id="disk-uuid" /> ... </disks> </backup> ---- The response body: [source,xml] ---- <backup id="backup-uuid"> <from_checkpoint_id>previous-checkpoint-uuid</from_checkpoint_id> <to_checkpoint_id>new-checkpoint-uuid</to_checkpoint_id> <disks> <disk id="disk-uuid" /> ... ... </disks> <status>initializing</status> <creation_date> </backup> ---- This method supports the following parameters: `backup`:: The information about the virtual machine backup entity. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('backup', backup, types.Backup), ('require_consistency', require_consistency, bool), ]) # Build the URL: query = query or {} if require_consistency is not None: require_consistency = Writer.render_boolean(require_consistency) query['require_consistency'] = require_consistency # Send the request and wait for the response: return self._internal_add(backup, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ The list of virtual machine backups. This method supports the following parameters: `max`:: Sets the maximum number of virtual machine backups to return. If not specified, all the virtual machine backups are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def backup_service(self, id): """ Returns a reference to the service that manages a specific VM backup. """ Service._check_types([ ('id', id, str), ]) return VmBackupService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.backup_service(path) return self.backup_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmBackupsService:%s' % self._path class VmCdromService(Service): """ Manages a CDROM device of a virtual machine. Changing and ejecting the disk is done using always the `update` method, to change the value of the `file` attribute. """ def __init__(self, connection, path): super(VmCdromService, self).__init__(connection, path) def get( self, current=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about this CDROM device. The information consists of `cdrom` attribute containing reference to the CDROM device, the virtual machine, and optionally the inserted disk. If there is a disk inserted then the `file` attribute will contain a reference to the ISO image: [source,xml] ---- <cdrom href="..." id="00000000-0000-0000-0000-000000000000"> <file id="mycd.iso"/> <vm href="/ovirt-engine/api/vms/123" id="123"/> </cdrom> ---- If there is no disk inserted then the `file` attribute won't be reported: [source,xml] ---- <cdrom href="..." id="00000000-0000-0000-0000-000000000000"> <vm href="/ovirt-engine/api/vms/123" id="123"/> </cdrom> ---- This method supports the following parameters: `current`:: Indicates if the operation should return the information for the currently running virtual machine. This parameter is optional, and the default value is `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('current', current, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if current is not None: current = Writer.render_boolean(current) query['current'] = current if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def update( self, cdrom, current=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the information about this CDROM device. It allows to change or eject the disk by changing the value of the `file` attribute. For example, to insert or change the disk send a request like this: [source] ---- PUT /ovirt-engine/api/vms/123/cdroms/00000000-0000-0000-0000-000000000000 ---- The body should contain the new value for the `file` attribute: [source,xml] ---- <cdrom> <file id="mycd.iso"/> </cdrom> ---- The value of the `id` attribute, `mycd.iso` in this example, should correspond to a file available in an attached ISO storage domain. To eject the disk use a `file` with an empty `id`: [source,xml] ---- <cdrom> <file id=""/> </cdrom> ---- By default the above operations change permanently the disk that will be visible to the virtual machine after the next boot, but they don't have any effect on the currently running virtual machine. If you want to change the disk that is visible to the current running virtual machine, add the `current=true` parameter. For example, to eject the current disk send a request like this: [source] ---- PUT /ovirt-engine/api/vms/123/cdroms/00000000-0000-0000-0000-000000000000?current=true ---- With a request body like this: [source,xml] ---- <cdrom> <file id=""/> </cdrom> ---- IMPORTANT: The changes made with the `current=true` parameter are never persisted, so they won't have any effect after the virtual machine is rebooted. This method supports the following parameters: `cdrom`:: The information about the CDROM device. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('cdrom', cdrom, types.Cdrom), ('current', current, bool), ]) # Build the URL: query = query or {} if current is not None: current = Writer.render_boolean(current) query['current'] = current # Send the request and wait for the response: return self._internal_update(cdrom, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmCdromService:%s' % self._path class VmCdromsService(Service): """ Manages the CDROM devices of a virtual machine. Currently virtual machines have exactly one CDROM device. No new devices can be added, and the existing one can't be removed, thus there are no `add` or `remove` methods. Changing and ejecting CDROM disks is done with the <<services/vm_cdrom/methods/update, update>> method of the <<services/vm_cdrom, service>> that manages the CDROM device. """ def __init__(self, connection, path): super(VmCdromsService, self).__init__(connection, path) self._cdrom_service = None def add( self, cdrom, headers=None, query=None, wait=True, **kwargs ): """ Add a cdrom to a virtual machine identified by the given id. """ # Check the types of the parameters: Service._check_types([ ('cdrom', cdrom, types.Cdrom), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(cdrom, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of CDROM devices of the virtual machine. The order of the returned list of CD-ROM devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of CDROMs to return. If not specified all the CDROMs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def cdrom_service(self, id): """ Returns a reference to the service that manages a specific CDROM device. """ Service._check_types([ ('id', id, str), ]) return VmCdromService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.cdrom_service(path) return self.cdrom_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmCdromsService:%s' % self._path class VmCheckpointService(Service): """ A service managing a checkpoint of a virtual machines. """ def __init__(self, connection, path): super(VmCheckpointService, self).__init__(connection, path) self._disks_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns information about the virtual machine checkpoint. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the virtual machine checkpoint entity. Remove the checkpoint from libvirt and the database. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def disks_service(self): """ A reference to the service that lists the disks in checkpoint. """ return VmCheckpointDisksService(self._connection, '%s/disks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmCheckpointService:%s' % self._path class VmCheckpointDiskService(Service): """ """ def __init__(self, connection, path): super(VmCheckpointDiskService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmCheckpointDiskService:%s' % self._path class VmCheckpointDisksService(Service): """ """ def __init__(self, connection, path): super(VmCheckpointDisksService, self).__init__(connection, path) self._disk_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks in checkpoint. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified, all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ A reference to the service that manages a specific disk. """ Service._check_types([ ('id', id, str), ]) return VmCheckpointDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmCheckpointDisksService:%s' % self._path class VmCheckpointsService(Service): """ Lists the checkpoints of a virtual machine. """ def __init__(self, connection, path): super(VmCheckpointsService, self).__init__(connection, path) self._checkpoint_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ The list of virtual machine checkpoints. This method supports the following parameters: `max`:: Sets the maximum number of virtual machine checkpoints to return. If not specified, all the virtual machine checkpoints are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def checkpoint_service(self, id): """ Returns a reference to the service that manages a specific VM checkpoint. """ Service._check_types([ ('id', id, str), ]) return VmCheckpointService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.checkpoint_service(path) return self.checkpoint_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmCheckpointsService:%s' % self._path class VmDiskService(MeasurableService): """ """ def __init__(self, connection, path): super(VmDiskService, self).__init__(connection, path) self._permissions_service = None self._statistics_service = None def activate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait) def deactivate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the deactivation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'deactivate', None, headers, query, wait) def export( self, async_=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the export should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def move( self, async_=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the move should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait) def reduce( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Reduces the size of the disk image. Invokes _reduce_ on the logical volume (i.e. this is only applicable for block storage domains). This is applicable for floating disks and disks attached to non-running virtual machines. There is no need to specify the size as the optimal size is calculated automatically. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reduce', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Detach the disk from the virtual machine. NOTE: In version 3 of the API this used to also remove the disk completely from the system, but starting with version 4 it doesn't. If you need to remove it completely use the <<services/disk/methods/remove,remove method of the top level disk service>>. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, disk, async_=None, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(disk, headers, query, wait) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmDiskService:%s' % self._path class VmDisksService(Service): """ """ def __init__(self, connection, path): super(VmDisksService, self).__init__(connection, path) self._disk_service = None def add( self, disk, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks of the virtual machine. The order of the returned list of disks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmDisksService:%s' % self._path class VmGraphicsConsoleService(Service): """ """ def __init__(self, connection, path): super(VmGraphicsConsoleService, self).__init__(connection, path) def get( self, current=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the graphics console configuration of the virtual machine. IMPORTANT: By default, when the `current` parameter is not specified, the data returned corresponds to the next execution of the virtual machine. In the current implementation of the system this means that the `address` and `port` attributes will not be populated because the system does not know what address and port will be used for the next execution. Since in most cases those attributes are needed, it is strongly advised to aways explicitly include the `current` parameter with the value `true`. This method supports the following parameters: `current`:: Specifies if the data returned should correspond to the next execution of the virtual machine, or to the current execution. IMPORTANT: The `address` and `port` attributes will not be populated unless the value is `true`. For example, to get data for the current execution of the virtual machine, including the `address` and `port` attributes, send a request like this: [source] ---- GET /ovit-engine/api/vms/123/graphicsconsoles/456?current=true ---- The default value is `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('current', current, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if current is not None: current = Writer.render_boolean(current) query['current'] = current if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def proxy_ticket( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the generation of the ticket should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'proxyticket', 'proxy_ticket', headers, query, wait) def remote_viewer_connection_file( self, headers=None, query=None, wait=True, **kwargs ): """ Generates the file which is compatible with `remote-viewer` client. Use the following request to generate remote viewer connection file of the graphics console. Note that this action generates the file only if virtual machine is running. [source] ---- POST /ovirt-engine/api/vms/123/graphicsconsoles/456/remoteviewerconnectionfile ---- The `remoteviewerconnectionfile` action does not take any action specific parameters, so the request body should contain an empty `action`: [source,xml] ---- <action/> ---- The response contains the file, which can be used with `remote-viewer` client. [source,xml] ---- <action> <remote_viewer_connection_file> [virt-viewer] type=spice host=192.168.1.101 port=-1 password=123456789 delete-this-file=1 fullscreen=0 toggle-fullscreen=shift+f11 release-cursor=shift+f12 secure-attention=ctrl+alt+end tls-port=5900 enable-smartcard=0 enable-usb-autoshare=0 usb-filter=null tls-ciphers=DEFAULT host-subject=O=local,CN=example.com ca=... </remote_viewer_connection_file> </action> ---- E.g., to fetch the content of remote viewer connection file and save it into temporary file, user can use oVirt Python SDK as follows: [source,python] ---- # Find the virtual machine: vm = vms_service.list(search='name=myvm')[0] # Locate the service that manages the virtual machine, as that is where # the locators are defined: vm_service = vms_service.vm_service(vm.id) # Find the graphic console of the virtual machine: graphics_consoles_service = vm_service.graphics_consoles_service() graphics_console = graphics_consoles_service.list()[0] # Generate the remote viewer connection file: console_service = graphics_consoles_service.console_service(graphics_console.id) remote_viewer_connection_file = console_service.remote_viewer_connection_file() # Write the content to file "/tmp/remote_viewer_connection_file.vv" path = "/tmp/remote_viewer_connection_file.vv" with open(path, "w") as f: f.write(remote_viewer_connection_file) ---- When you create the remote viewer connection file, then you can connect to virtual machine graphic console, as follows: [source,bash] ---- #!/bin/sh -ex remote-viewer --ovirt-ca-file=/etc/pki/ovirt-engine/ca.pem /tmp/remote_viewer_connection_file.vv ---- """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'remoteviewerconnectionfile', 'remote_viewer_connection_file', headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the graphics console from the virtual machine. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def ticket( self, ticket=None, headers=None, query=None, wait=True, **kwargs ): """ Generates a time-sensitive authentication token for accessing this virtual machine's console. [source] ---- POST /ovirt-engine/api/vms/123/graphicsconsoles/456/ticket ---- The client-provided action optionally includes a desired ticket value and/or an expiry time in seconds. In any case, the response specifies the actual ticket value and expiry used. [source,xml] ---- <action> <ticket> <value>abcd12345</value> <expiry>120</expiry> </ticket> </action> ---- This method supports the following parameters: `ticket`:: The generated ticket that can be used to access this console. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('ticket', ticket, types.Ticket), ]) # Populate the action: action = types.Action( ticket=ticket, ) # Send the request and wait for the response: return self._internal_action(action, 'ticket', 'ticket', headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmGraphicsConsoleService:%s' % self._path class VmGraphicsConsolesService(Service): """ """ def __init__(self, connection, path): super(VmGraphicsConsolesService, self).__init__(connection, path) self._console_service = None def add( self, console, headers=None, query=None, wait=True, **kwargs ): """ Add new graphics console to the virtual machine. """ # Check the types of the parameters: Service._check_types([ ('console', console, types.GraphicsConsole), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(console, headers, query, wait) def list( self, current=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured graphics consoles of the virtual machine. IMPORTANT: By default, when the `current` parameter is not specified, the data returned corresponds to the next execution of the virtual machine. In the current implementation of the system this means that the `address` and `port` attributes will not be populated because the system does not know what address and port will be used for the next execution. Since in most cases those attributes are needed, it is strongly advised to aways explicitly include the `current` parameter with the value `true`. The order of the returned list of graphics consoles is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of consoles to return. If not specified all the consoles are returned. `current`:: Specifies if the data returned should correspond to the next execution of the virtual machine, or to the current execution. IMPORTANT: The `address` and `port` attributes will not be populated unless the value is `true`. For example, to get data for the current execution of the virtual machine, including the `address` and `port` attributes, send a request like this: [source] ---- GET /ovirt-engine/api/vms/123/graphicsconsoles?current=true ---- The default value is `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('current', current, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if current is not None: current = Writer.render_boolean(current) query['current'] = current if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def console_service(self, id): """ Returns a reference to the service that manages a specific virtual machine graphics console. """ Service._check_types([ ('id', id, str), ]) return VmGraphicsConsoleService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.console_service(path) return self.console_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmGraphicsConsolesService:%s' % self._path class VmHostDeviceService(Service): """ A service to manage individual host device attached to a virtual machine. """ def __init__(self, connection, path): super(VmHostDeviceService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieve information about particular host device attached to given virtual machine. Example: [source] ---- GET /ovirt-engine/api/vms/123/hostdevices/456 ---- [source,xml] ---- <host_device href="/ovirt-engine/api/hosts/543/devices/456" id="456"> <name>pci_0000_04_00_0</name> <capability>pci</capability> <iommu_group>30</iommu_group> <placeholder>true</placeholder> <product id="0x13ba"> <name>GM107GL [Quadro K2200]</name> </product> <vendor id="0x10de"> <name>NVIDIA Corporation</name> </vendor> <host href="/ovirt-engine/api/hosts/543" id="543"/> <parent_device href="/ovirt-engine/api/hosts/543/devices/456" id="456"> <name>pci_0000_00_03_0</name> </parent_device> <vm href="/ovirt-engine/api/vms/123" id="123"/> </host_device> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the attachment of this host device from given virtual machine. NOTE: In case this device serves as an IOMMU placeholder, it cannot be removed (remove will result only in setting its `placeholder` flag to `true`). Note that all IOMMU placeholder devices will be removed automatically as soon as there will be no more non-placeholder devices (all devices from given IOMMU group are detached). [source] ---- DELETE /ovirt-engine/api/vms/123/hostdevices/456 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmHostDeviceService:%s' % self._path class VmHostDevicesService(Service): """ A service to manage host devices attached to a virtual machine. """ def __init__(self, connection, path): super(VmHostDevicesService, self).__init__(connection, path) self._device_service = None def add( self, device, headers=None, query=None, wait=True, **kwargs ): """ Attach target device to given virtual machine. Example: [source] ---- POST /ovirt-engine/api/vms/123/hostdevices ---- With request body of type <<types/host_device,HostDevice>>, for example [source,xml] ---- <host_device id="123" /> ---- NOTE: A necessary precondition for a successful host device attachment is that the virtual machine must be pinned to *exactly* one host. The device ID is then taken relative to this host. NOTE: Attachment of a PCI device that is part of a bigger IOMMU group will result in attachment of the remaining devices from that IOMMU group as "placeholders". These devices are then identified using the `placeholder` attribute of the <<types/host_device,HostDevice>> type set to `true`. In case you want attach a device that already serves as an IOMMU placeholder, simply issue an explicit Add operation for it, and its `placeholder` flag will be cleared, and the device will be accessible to the virtual machine. This method supports the following parameters: `device`:: The host device to be attached to given virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('device', device, types.HostDevice), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(device, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the host devices assigned to given virtual machine. The order of the returned list of devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of devices to return. If not specified all the devices are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def device_service(self, id): """ Returns a reference to the service that manages a specific host device attached to given virtual machine. """ Service._check_types([ ('id', id, str), ]) return VmHostDeviceService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.device_service(path) return self.device_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmHostDevicesService:%s' % self._path class VmNicService(MeasurableService): """ """ def __init__(self, connection, path): super(VmNicService, self).__init__(connection, path) self._network_filter_parameters_service = None self._reported_devices_service = None self._statistics_service = None def activate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait) def deactivate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the deactivation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'deactivate', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the NIC. For example, to remove the NIC with id `456` from the virtual machine with id `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/vms/123/nics/456 ---- [IMPORTANT] ==== The hotplugging feature only supports virtual machine operating systems with hotplugging operations. Example operating systems include: - Red Hat Enterprise Linux 6 - Red Hat Enterprise Linux 5 - Windows Server 2008 and - Windows Server 2003 ==== This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, nic, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the NIC. For example, to update the NIC having with `456` belonging to virtual the machine with id `123` send a request like this: [source] ---- PUT /ovirt-engine/api/vms/123/nics/456 ---- With a request body like this: [source,xml] ---- <nic> <name>mynic</name> <interface>e1000</interface> <vnic_profile id='789'/> </nic> ---- [IMPORTANT] ==== The hotplugging feature only supports virtual machine operating systems with hotplugging operations. Example operating systems include: - Red Hat Enterprise Linux 6 - Red Hat Enterprise Linux 5 - Windows Server 2008 and - Windows Server 2003 ==== """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(nic, headers, query, wait) def network_filter_parameters_service(self): """ Reference to the service that manages the network filter parameters of the NIC. A single top-level network filter may assigned to the NIC by the NIC's <<types/vnic_profile,vNIC Profile>>. """ return NicNetworkFilterParametersService(self._connection, '%s/networkfilterparameters' % self._path) def reported_devices_service(self): """ """ return VmReportedDevicesService(self._connection, '%s/reporteddevices' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'networkfilterparameters': return self.network_filter_parameters_service() if path.startswith('networkfilterparameters/'): return self.network_filter_parameters_service().service(path[24:]) if path == 'reporteddevices': return self.reported_devices_service() if path.startswith('reporteddevices/'): return self.reported_devices_service().service(path[16:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmNicService:%s' % self._path class VmNicsService(Service): """ """ def __init__(self, connection, path): super(VmNicsService, self).__init__(connection, path) self._nic_service = None def add( self, nic, headers=None, query=None, wait=True, **kwargs ): """ Adds a NIC to the virtual machine. The following example adds to the virtual machine `123` a network interface named `mynic` using `virtio` and the NIC profile `456`. [source] ---- POST /ovirt-engine/api/vms/123/nics ---- [source,xml] ---- <nic> <name>mynic</name> <interface>virtio</interface> <vnic_profile id="456"/> </nic> ---- The following example sends that request using `curl`: [source,bash] ---- curl \ --request POST \ --header "Version: 4" \ --header "Content-Type: application/xml" \ --header "Accept: application/xml" \ --user "admin@internal:mypassword" \ --cacert /etc/pki/ovirt-engine/ca.pem \ --data ' <nic> <name>mynic</name> <interface>virtio</interface> <vnic_profile id="456"/> </nic> ' \ https://myengine.example.com/ovirt-engine/api/vms/123/nics ---- [IMPORTANT] ==== The hotplugging feature only supports virtual machine operating systems with hotplugging operations. Example operating systems include: - Red Hat Enterprise Linux 6 - Red Hat Enterprise Linux 5 - Windows Server 2008 and - Windows Server 2003 ==== """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(nic, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of NICs of the virtual machine. The order of the returned list of NICs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def nic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmNicService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmNicsService:%s' % self._path class VmNumaNodeService(Service): """ """ def __init__(self, connection, path): super(VmNumaNodeService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a virtual NUMA node. An example of removing a virtual NUMA node: [source] ---- DELETE /ovirt-engine/api/vms/123/numanodes/456 ---- NOTE: It's required to remove the numa nodes from the highest index first. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, node, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a virtual NUMA node. An example of pinning a virtual NUMA node to a physical NUMA node on the host: [source] ---- PUT /ovirt-engine/api/vms/123/numanodes/456 ---- The request body should contain the following: [source,xml] ---- <vm_numa_node> <numa_node_pins> <numa_node_pin> <index>0</index> </numa_node_pin> </numa_node_pins> </vm_numa_node> ---- """ # Check the types of the parameters: Service._check_types([ ('node', node, types.VirtualNumaNode), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(node, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmNumaNodeService:%s' % self._path class VmNumaNodesService(Service): """ """ def __init__(self, connection, path): super(VmNumaNodesService, self).__init__(connection, path) self._node_service = None def add( self, node, headers=None, query=None, wait=True, **kwargs ): """ Creates a new virtual NUMA node for the virtual machine. An example of creating a NUMA node: [source] ---- POST /ovirt-engine/api/vms/c7ecd2dc/numanodes Accept: application/xml Content-type: application/xml ---- The request body can contain the following: [source,xml] ---- <vm_numa_node> <cpu> <cores> <core> <index>0</index> </core> </cores> </cpu> <index>0</index> <memory>1024</memory> <numa_tune_mode>strict</numa_tune_mode> </vm_numa_node> ---- """ # Check the types of the parameters: Service._check_types([ ('node', node, types.VirtualNumaNode), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(node, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists virtual NUMA nodes of a virtual machine. The order of the returned list of NUMA nodes isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of nodes to return. If not specified all the nodes are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def node_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmNumaNodeService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.node_service(path) return self.node_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmNumaNodesService:%s' % self._path class VmPoolService(Service): """ A service to manage a virtual machines pool. """ def __init__(self, connection, path): super(VmPoolService, self).__init__(connection, path) self._permissions_service = None def allocate_vm( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation allocates a virtual machine in the virtual machine pool. [source] ---- POST /ovirt-engine/api/vmpools/123/allocatevm ---- The allocate virtual machine action does not take any action specific parameters, so the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the allocation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'allocatevm', None, headers, query, wait) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get the virtual machine pool. [source] ---- GET /ovirt-engine/api/vmpools/123 ---- You will get a XML response like that one: [source,xml] ---- <vm_pool id="123"> <actions>...</actions> <name>MyVmPool</name> <description>MyVmPool description</description> <link href="/ovirt-engine/api/vmpools/123/permissions" rel="permissions"/> <max_user_vms>1</max_user_vms> <prestarted_vms>0</prestarted_vms> <size>100</size> <stateful>false</stateful> <type>automatic</type> <use_latest_template_version>false</use_latest_template_version> <cluster id="123"/> <template id="123"/> <vm id="123">...</vm> ... </vm_pool> ---- This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a virtual machine pool. [source] ---- DELETE /ovirt-engine/api/vmpools/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, pool, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the virtual machine pool. [source] ---- PUT /ovirt-engine/api/vmpools/123 ---- The `name`, `description`, `size`, `prestarted_vms` and `max_user_vms` attributes can be updated after the virtual machine pool has been created. [source,xml] ---- <vmpool> <name>VM_Pool_B</name> <description>Virtual Machine Pool B</description> <size>3</size> <prestarted_vms>1</size> <max_user_vms>2</size> </vmpool> ---- This method supports the following parameters: `pool`:: The virtual machine pool that is being updated. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('pool', pool, types.VmPool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(pool, headers, query, wait) def permissions_service(self): """ Reference to a service managing the virtual machine pool assigned permissions. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmPoolService:%s' % self._path class VmPoolsService(Service): """ Provides read-write access to virtual machines pools. """ def __init__(self, connection, path): super(VmPoolsService, self).__init__(connection, path) self._pool_service = None def add( self, pool, headers=None, query=None, wait=True, **kwargs ): """ Creates a new virtual machine pool. A new pool requires the `name`, `cluster` and `template` attributes. Identify the cluster and template with the `id` or `name` nested attributes: [source] ---- POST /ovirt-engine/api/vmpools ---- With the following body: [source,xml] ---- <vmpool> <name>mypool</name> <cluster id="123"/> <template id="456"/> </vmpool> ---- This method supports the following parameters: `pool`:: Pool to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('pool', pool, types.VmPool), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(pool, headers, query, wait) def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Get a list of available virtual machines pools. [source] ---- GET /ovirt-engine/api/vmpools ---- You will receive the following response: [source,xml] ---- <vm_pools> <vm_pool id="123"> ... </vm_pool> ... </vm_pools> ---- The order of the returned list of pools is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of pools to return. If this value is not specified, all of the pools are returned. `search`:: A query string used to restrict the returned pools. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def pool_service(self, id): """ Reference to the service that manages a specific virtual machine pool. """ Service._check_types([ ('id', id, str), ]) return VmPoolService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.pool_service(path) return self.pool_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmPoolsService:%s' % self._path class VmReportedDeviceService(Service): """ """ def __init__(self, connection, path): super(VmReportedDeviceService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmReportedDeviceService:%s' % self._path class VmReportedDevicesService(Service): """ """ def __init__(self, connection, path): super(VmReportedDevicesService, self).__init__(connection, path) self._reported_device_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of reported devices of the virtual machine. The order of the returned list of devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of devices to return. If not specified all the devices are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def reported_device_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmReportedDeviceService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.reported_device_service(path) return self.reported_device_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmReportedDevicesService:%s' % self._path class VmSessionService(Service): """ """ def __init__(self, connection, path): super(VmSessionService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmSessionService:%s' % self._path class VmSessionsService(Service): """ Provides information about virtual machine user sessions. """ def __init__(self, connection, path): super(VmSessionsService, self).__init__(connection, path) self._session_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all user sessions for this virtual machine. For example, to retrieve the session information for virtual machine `123` send a request like this: [source] ---- GET /ovirt-engine/api/vms/123/sessions ---- The response body will contain something like this: [source,xml] ---- <sessions> <session href="/ovirt-engine/api/vms/123/sessions/456" id="456"> <console_user>true</console_user> <ip> <address>192.168.122.1</address> </ip> <user href="/ovirt-engine/api/users/789" id="789"/> <vm href="/ovirt-engine/api/vms/123" id="123"/> </session> ... </sessions> ---- The order of the returned list of sessions isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of sessions to return. If not specified all the sessions are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def session_service(self, id): """ Reference to the service that manages a specific session. """ Service._check_types([ ('id', id, str), ]) return VmSessionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.session_service(path) return self.session_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmSessionsService:%s' % self._path class VmWatchdogService(Service): """ A service managing a watchdog on virtual machines. """ def __init__(self, connection, path): super(VmWatchdogService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about the watchdog. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the watchdog from the virtual machine. For example, to remove a watchdog from a virtual machine, send a request like this: [source] ---- DELETE /ovirt-engine/api/vms/123/watchdogs/00000000-0000-0000-0000-000000000000 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, watchdog, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the information about the watchdog. You can update the information using `action` and `model` elements. For example, to update a watchdog, send a request like this: [source] ---- PUT /ovirt-engine/api/vms/123/watchdogs <watchdog> <action>reset</action> </watchdog> ---- with response body: [source,xml] ---- <watchdog href="/ovirt-engine/api/vms/123/watchdogs/00000000-0000-0000-0000-000000000000" id="00000000-0000-0000-0000-000000000000"> <vm href="/ovirt-engine/api/vms/123" id="123"/> <action>reset</action> <model>i6300esb</model> </watchdog> ---- This method supports the following parameters: `watchdog`:: The information about the watchdog. The request data must contain at least one of `model` and `action` elements. The response data contains complete information about the updated watchdog. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(watchdog, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmWatchdogService:%s' % self._path class VmWatchdogsService(Service): """ Lists the watchdogs of a virtual machine. """ def __init__(self, connection, path): super(VmWatchdogsService, self).__init__(connection, path) self._watchdog_service = None def add( self, watchdog, headers=None, query=None, wait=True, **kwargs ): """ Adds new watchdog to the virtual machine. For example, to add a watchdog to a virtual machine, send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/watchdogs <watchdog> <action>poweroff</action> <model>i6300esb</model> </watchdog> ---- with response body: [source,xml] ---- <watchdog href="/ovirt-engine/api/vms/123/watchdogs/00000000-0000-0000-0000-000000000000" id="00000000-0000-0000-0000-000000000000"> <vm href="/ovirt-engine/api/vms/123" id="123"/> <action>poweroff</action> <model>i6300esb</model> </watchdog> ---- This method supports the following parameters: `watchdog`:: The information about the watchdog. The request data must contain `model` element (such as `i6300esb`) and `action` element (one of `none`, `reset`, `poweroff`, `dump`, `pause`). The response data additionally contains references to the added watchdog and to the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(watchdog, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ The list of watchdogs of the virtual machine. The order of the returned list of watchdogs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of watchdogs to return. If not specified all the watchdogs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def watchdog_service(self, id): """ Returns a reference to the service that manages a specific watchdog. """ Service._check_types([ ('id', id, str), ]) return VmWatchdogService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.watchdog_service(path) return self.watchdog_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmWatchdogsService:%s' % self._path class VmsService(Service): """ """ def __init__(self, connection, path): super(VmsService, self).__init__(connection, path) self._vm_service = None def add( self, vm, auto_pinning_policy=None, clone=None, clone_permissions=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ Creates a new virtual machine. The virtual machine can be created in different ways: - From a template. In this case the identifier or name of the template must be provided. For example, using a plain shell script and XML: [source,bash] ---- #!/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 ' <vm> <name>myvm</name> <template> <name>Blank</name> </template> <cluster> <name>mycluster</name> </cluster> </vm> ' \ "${url}/vms" ---- - From a snapshot. In this case the identifier of the snapshot has to be provided. For example, using a plain shel script and XML: [source,bash] ---- #!/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 "Content-Type: application/xml" \ --header "Accept: application/xml" \ --data ' <vm> <name>myvm</name> <snapshots> <snapshot id="266742a5-6a65-483c-816d-d2ce49746680"/> </snapshots> <cluster> <name>mycluster</name> </cluster> </vm> ' \ "${url}/vms" ---- When creating a virtual machine from a template or from a snapshot it is usually useful to explicitly indicate in what storage domain to create the disks for the virtual machine. If the virtual machine is created from a template then this is achieved passing a set of `disk_attachment` elements that indicate the mapping: [source,xml] ---- <vm> ... <disk_attachments> <disk_attachment> <disk id="8d4bd566-6c86-4592-a4a7-912dbf93c298"> <storage_domains> <storage_domain id="9cb6cb0a-cf1d-41c2-92ca-5a6d665649c9"/> </storage_domains> </disk> <disk_attachment> </disk_attachments> </vm> ---- When the virtual machine is created from a snapshot this set of disks is slightly different, it uses the `image_id` attribute instead of `id`. [source,xml] ---- <vm> ... <disk_attachments> <disk_attachment> <disk> <image_id>8d4bd566-6c86-4592-a4a7-912dbf93c298</image_id> <storage_domains> <storage_domain id="9cb6cb0a-cf1d-41c2-92ca-5a6d665649c9"/> </storage_domains> </disk> <disk_attachment> </disk_attachments> </vm> ---- It is possible to specify additional virtual machine parameters in the XML description, e.g. a virtual machine of `desktop` type, with 2 GiB of RAM and additional description can be added sending a request body like the following: [source,xml] ---- <vm> <name>myvm</name> <description>My Desktop Virtual Machine</description> <type>desktop</type> <memory>2147483648</memory> ... </vm> ---- A bootable CDROM device can be set like this: [source,xml] ---- <vm> ... <os> <boot dev="cdrom"/> </os> </vm> ---- In order to boot from CDROM, you first need to insert a disk, as described in the <<services/vm_cdrom, CDROM service>>. Then booting from that CDROM can be specified using the `os.boot.devices` attribute: [source,xml] ---- <vm> ... <os> <boot> <devices> <device>cdrom</device> </devices> </boot> </os> </vm> ---- In all cases the name or identifier of the cluster where the virtual machine will be created is mandatory. """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('auto_pinning_policy', auto_pinning_policy, types.AutoPinningPolicy), ('clone', clone, bool), ('clone_permissions', clone_permissions, bool), ('filter', filter, bool), ]) # Build the URL: query = query or {} if auto_pinning_policy is not None: query['auto_pinning_policy'] = auto_pinning_policy if clone is not None: clone = Writer.render_boolean(clone) query['clone'] = clone if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait) def add_from_configuration( self, vm, auto_pinning_policy=None, clone=None, clone_permissions=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ add a virtual machine to the system from a configuration - requires the configuration type and the configuration data """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('auto_pinning_policy', auto_pinning_policy, types.AutoPinningPolicy), ('clone', clone, bool), ('clone_permissions', clone_permissions, bool), ('filter', filter, bool), ]) # Build the URL: query = query or {} if auto_pinning_policy is not None: query['auto_pinning_policy'] = auto_pinning_policy if clone is not None: clone = Writer.render_boolean(clone) query['clone'] = clone if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait) def add_from_scratch( self, vm, auto_pinning_policy=None, clone=None, clone_permissions=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ add a virtual machine to the system from scratch """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('auto_pinning_policy', auto_pinning_policy, types.AutoPinningPolicy), ('clone', clone, bool), ('clone_permissions', clone_permissions, bool), ('filter', filter, bool), ]) # Build the URL: query = query or {} if auto_pinning_policy is not None: query['auto_pinning_policy'] = auto_pinning_policy if clone is not None: clone = Writer.render_boolean(clone) query['clone'] = clone if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait) def add_from_snapshot( self, vm, auto_pinning_policy=None, clone=None, clone_permissions=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ add a virtual machine to the system by cloning from a snapshot """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('auto_pinning_policy', auto_pinning_policy, types.AutoPinningPolicy), ('clone', clone, bool), ('clone_permissions', clone_permissions, bool), ('filter', filter, bool), ]) # Build the URL: query = query or {} if auto_pinning_policy is not None: query['auto_pinning_policy'] = auto_pinning_policy if clone is not None: clone = Writer.render_boolean(clone) query['clone'] = clone if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait) def list( self, all_content=None, case_sensitive=None, filter=None, follow=None, max=None, ovf_as_ova=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of virtual machines of the system. The order of the returned list of virtual machines is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `search`:: A query string used to restrict the returned virtual machines. `max`:: The maximum number of results to return. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `all_content`:: Indicates if all the attributes of the virtual machines should be included in the response. By default the following attributes are excluded: - `console` - `initialization.configuration.data` - The OVF document describing the virtual machine. - `rng_source` - `soundcard` - `virtio_scsi` For example, to retrieve the complete representation of the virtual machines send a request like this: .... GET /ovirt-engine/api/vms?all_content=true .... NOTE: The reason for not including these attributes is performance: they are seldom used and they require additional queries to the database. So try to use the this parameter only when it is really needed. `ovf_as_ova`:: Indicates if the results should expose the OVF as it appears in OVA files of that VM. The OVF document describing the virtual machine. This parameter will work only when all_content=True is set. The OVF will be presented in `initialization.configuration.data`. For example: [source] ---- GET /vms?all_content=true&ovf_as_ova=true ---- `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('ovf_as_ova', ovf_as_ova, bool), ('search', search, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if ovf_as_ova is not None: ovf_as_ova = Writer.render_boolean(ovf_as_ova) query['ovf_as_ova'] = ovf_as_ova if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def vm_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.vm_service(path) return self.vm_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmsService:%s' % self._path class VnicProfileService(Service): """ This service manages a vNIC profile. """ def __init__(self, connection, path): super(VnicProfileService, self).__init__(connection, path) self._permissions_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves details about a vNIC profile. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the vNIC profile. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, profile, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates details of a vNIC profile. This method supports the following parameters: `profile`:: The vNIC profile that is being updated. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.VnicProfile), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(profile, headers, query, wait) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VnicProfileService:%s' % self._path class VnicProfilesService(Service): """ This service manages the collection of all vNIC profiles. """ def __init__(self, connection, path): super(VnicProfilesService, self).__init__(connection, path) self._profile_service = None def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a vNIC profile. For example to add vNIC profile `123` to network `456` send a request to: [source] ---- POST /ovirt-engine/api/networks/456/vnicprofiles ---- With the following body: [source,xml] ---- <vnic_profile id="123"> <name>new_vNIC_name</name> <pass_through> <mode>disabled</mode> </pass_through> <port_mirroring>false</port_mirroring> </vnic_profile> ---- Please note that there is a default network filter to each VNIC profile. For more details of how the default network filter is calculated please refer to the documentation in <<services/network_filters,NetworkFilters>>. NOTE: The automatically created vNIC profile for the external network will be without network filter. The output of creating a new VNIC profile depends in the body arguments that were given. In case no network filter was given, the default network filter will be configured. For example: [source,xml] ---- <vnic_profile href="/ovirt-engine/api/vnicprofiles/123" id="123"> <name>new_vNIC_name</name> <link href="/ovirt-engine/api/vnicprofiles/123/permissions" rel="permissions"/> <pass_through> <mode>disabled</mode> </pass_through> <port_mirroring>false</port_mirroring> <network href="/ovirt-engine/api/networks/456" id="456"/> <network_filter href="/ovirt-engine/api/networkfilters/789" id="789"/> </vnic_profile> ---- In case an empty network filter was given, no network filter will be configured for the specific VNIC profile regardless of the VNIC profile's default network filter. For example: [source,xml] ---- <vnic_profile> <name>no_network_filter</name> <network_filter/> </vnic_profile> ---- In case that a specific valid network filter id was given, the VNIC profile will be configured with the given network filter regardless of the VNIC profiles's default network filter. For example: [source,xml] ---- <vnic_profile> <name>user_choice_network_filter</name> <network_filter id= "0000001b-001b-001b-001b-0000000001d5"/> </vnic_profile> ---- This method supports the following parameters: `profile`:: The vNIC profile that is being added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.VnicProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all vNIC profiles. The order of the returned list of vNIC profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VnicProfileService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VnicProfilesService:%s' % self._path class WeightService(Service): """ """ def __init__(self, connection, path): super(WeightService, self).__init__(connection, path) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'WeightService:%s' % self._path class WeightsService(Service): """ """ def __init__(self, connection, path): super(WeightsService, self).__init__(connection, path) self._weight_service = None def add( self, weight, headers=None, query=None, wait=True, **kwargs ): """ Add a weight to a specified user defined scheduling policy. """ # Check the types of the parameters: Service._check_types([ ('weight', weight, types.Weight), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(weight, headers, query, wait) def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of weights. The order of the returned list of weights isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of weights to return. If not specified all the weights are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def weight_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return WeightService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.weight_service(path) return self.weight_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'WeightsService:%s' % self._path class AttachedStorageDomainDiskService(MeasurableService): """ Manages a single disk available in a storage domain attached to a data center. IMPORTANT: Since version 4.2 of the engine this service is intended only to list disks available in the storage domain, and to register unregistered disks. All the other operations, like copying a disk, moving a disk, etc, have been deprecated and will be removed in the future. To perform those operations use the <<services/disks, service that manages all the disks of the system>>, or the <<services/disk, service that manages an specific disk>>. """ def __init__(self, connection, path): super(AttachedStorageDomainDiskService, self).__init__(connection, path) self._permissions_service = None self._statistics_service = None def copy( self, disk=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Copies a disk to the specified storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To copy a disk use the <<services/disk/methods/copy, copy>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: Description of the resulting disk. `storage_domain`:: The storage domain where the new disk will be created. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( disk=disk, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait) def export( self, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a disk to an export storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To export a disk use the <<services/disk/methods/export, export>> operation of the service that manages that disk. This method supports the following parameters: `storage_domain`:: The export storage domain where the disk should be exported to. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def move( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Moves a disk to another storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To move a disk use the <<services/disk/methods/move, move>> operation of the service that manages that disk. This method supports the following parameters: `storage_domain`:: The storage domain where the disk will be moved to. `async_`:: Indicates if the move should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait) def register( self, headers=None, query=None, wait=True, **kwargs ): """ Registers an unregistered disk. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'register', None, headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes a disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To remove a disk use the <<services/disk/methods/remove, remove>> operation of the service that manages that disk. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def sparsify( self, headers=None, query=None, wait=True, **kwargs ): """ Sparsify the disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To remove a disk use the <<services/disk/methods/remove, remove>> operation of the service that manages that disk. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'sparsify', None, headers, query, wait) def update( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Updates the disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To update a disk use the <<services/disk/methods/update, update>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: The update to apply to the disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(disk, headers, query, wait) def permissions_service(self): """ Reference to the service that manages the permissions assigned to the disk. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AttachedStorageDomainDiskService:%s' % self._path class DiskService(MeasurableService): """ Manages a single disk. """ def __init__(self, connection, path): super(DiskService, self).__init__(connection, path) self._disk_snapshots_service = None self._permissions_service = None self._statistics_service = None def copy( self, async_=None, disk=None, disk_profile=None, filter=None, quota=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ This operation copies a disk to the specified storage domain. For example, a disk can be copied using the following request: [source] ---- POST /ovirt-engine/api/disks/123/copy ---- With a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> <disk> <name>mydisk</name> </disk> </action> ---- If the disk profile or the quota currently used by the disk are not defined for the new storage domain, they can be explicitly specified. If they are not specified, the first available disk profile and the default quota are used. For example, to specify disk profile `987` and quota `753`, send a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> <disk_profile id="987"/> <quota id="753"/> </action> ---- This method supports the following parameters: `storage_domain`:: The storage domain where the new disk is created. This can be specified using the `id` or `name` attributes. For example, to copy a disk to the storage domain called `mydata`, send a request like this: .... POST /ovirt-engine/api/storagedomains/123/disks/789 .... With a request body like this: [source,xml] ---- <action> <storage_domain> <name>mydata</name> </storage_domain> </action> ---- `disk_profile`:: Disk profile for the disk in the new storage domain. Disk profiles are defined for storage domains, so the old disk profile will not exist in the new storage domain. If this parameter is not used, the first disk profile from the new storage domain to which the user has permissions will be assigned to the disk. `quota`:: Quota for the disk in the new storage domain. This optional parameter can be used to specify new quota for the disk, because the current quota may not be defined for the new storage domain. If this parameter is not used and the old quota is not defined for the new storage domain, the default (unlimited) quota will be assigned to the disk. `async_`:: Indicates if the copy should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('disk', disk, types.Disk), ('disk_profile', disk_profile, types.DiskProfile), ('filter', filter, bool), ('quota', quota, types.Quota), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, disk=disk, disk_profile=disk_profile, filter=filter, quota=quota, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait) def export( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a disk to an export storage domain. This method supports the following parameters: `storage_domain`:: The export storage domain where the disk will be exported to. `async_`:: Indicates if the export should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def get( self, all_content=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `all_content`:: Indicates if all of the attributes of the disk should be included in the response. By default the following disk attributes are excluded: - `vms` For example, to retrieve the complete representation of disk '123': .... GET /ovirt-engine/api/disks/123?all_content=true .... `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def move( self, async_=None, disk_profile=None, filter=None, quota=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Moves a disk to another storage domain. For example, to move the disk with identifier `123` to a storage domain with identifier `456` send the following request: [source] ---- POST /ovirt-engine/api/disks/123/move ---- With the following request body: [source,xml] ---- <action> <storage_domain id="456"/> </action> ---- If the disk profile or the quota used currently by the disk aren't defined for the new storage domain, then they can be explicitly specified. If they aren't then the first available disk profile and the default quota are used. For example, to explicitly use disk profile `987` and quota `753` send a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> <disk_profile id="987"/> <quota id="753"/> </action> ---- This method supports the following parameters: `storage_domain`:: The storage domain where the disk will be moved to. `disk_profile`:: Disk profile for the disk in the new storage domain. Disk profiles are defined for storage domains, so the old disk profile will not exist in the new storage domain. If this parameter is not used, the first disk profile from the new storage domain to which the user has permissions will be assigned to the disk. `quota`:: Quota for the disk in the new storage domain. This optional parameter can be used to specify new quota for the disk, because the current quota may not be defined for the new storage domain. If this parameter is not used and the old quota is not defined for the new storage domain, the default (unlimited) quota will be assigned to the disk. `async_`:: Indicates if the move should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('disk_profile', disk_profile, types.DiskProfile), ('filter', filter, bool), ('quota', quota, types.Quota), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, disk_profile=disk_profile, filter=filter, quota=quota, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait) def reduce( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Reduces the size of the disk image. Invokes _reduce_ on the logical volume (i.e. this is only applicable for block storage domains). This is applicable for floating disks and disks attached to non-running virtual machines. There is no need to specify the size as the optimal size is calculated automatically. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reduce', None, headers, query, wait) def refresh_lun( self, host=None, headers=None, query=None, wait=True, **kwargs ): """ Refreshes a direct LUN disk with up-to-date information from the storage. Refreshing a direct LUN disk is useful when: - The LUN was added using the API without the host parameter, and therefore does not contain any information from the storage (see <<services/disks/methods/add, DisksService::add>>). - New information about the LUN is available on the storage and you want to update the LUN with it. To refresh direct LUN disk `123` using host `456`, send the following request: [source] ---- POST /ovirt-engine/api/disks/123/refreshlun ---- With the following request body: [source,xml] ---- <action> <host id='456'/> </action> ---- This method supports the following parameters: `host`:: The host that will be used to refresh the direct LUN disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ]) # Populate the action: action = types.Action( host=host, ) # Send the request and wait for the response: return self._internal_action(action, 'refreshlun', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a disk. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def sparsify( self, headers=None, query=None, wait=True, **kwargs ): """ Sparsify the disk. Sparsification frees space in the disk image that is not used by its filesystem. As a result, the image will occupy less space on the storage. Currently sparsification works only on disks without snapshots. Disks having derived disks are also not allowed. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'sparsify', None, headers, query, wait) def update( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Updates the parameters of the specified disk. This operation allows updating the following floating disk properties: * For Image disks: `provisioned_size`, `alias`, `description`, `wipe_after_delete`, `shareable`, `backup` and `disk_profile`. * For LUN disks: `alias`, `description` and `shareable`. * For Cinder and Managed Block disks: `provisioned_size`, `alias` and `description`. * For VM attached disks, the `qcow_version` can also be updated. For example, a disk's update can be done by using the following request: [source] ---- PUT /ovirt-engine/api/disks/123 ---- With a request body like this: [source,xml] ---- <disk> <qcow_version>qcow2_v3</qcow_version> <alias>new-alias</alias> <description>new-desc</description> </disk> ---- Since the backend operation is asynchronous, the disk element that is returned to the user might not be synced with the changed properties. This method supports the following parameters: `disk`:: The update to apply to the disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(disk, headers, query, wait) def disk_snapshots_service(self): """ Reference to the service that manages the DiskSnapshots. For example, to list all disk snapshots under the disks resource '123': .... GET /ovirt-engine/api/disks/123/disksnapshots .... For example, to retrieve a specific disk snapshot '789' under the disk resource '123': .... GET /ovirt-engine/api/disks/123/disksnapshots/789 .... """ return DiskSnapshotsService(self._connection, '%s/disksnapshots' % self._path) def permissions_service(self): """ Reference to the service that manages the permissions assigned to the disk. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disksnapshots': return self.disk_snapshots_service() if path.startswith('disksnapshots/'): return self.disk_snapshots_service().service(path[14:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DiskService:%s' % self._path class EngineKatelloErrataService(KatelloErrataService): """ A service to manage Katello errata assigned to the engine. The information is retrieved from Katello. """ def __init__(self, connection, path): super(EngineKatelloErrataService, self).__init__(connection, path) self._katello_erratum_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representation of the Katello errata. [source] ---- GET /ovirt-engine/api/katelloerrata ---- You will receive response in XML like this one: [source,xml] ---- <katello_errata> <katello_erratum href="/ovirt-engine/api/katelloerrata/123" id="123"> <name>RHBA-2013:XYZ</name> <description>The description of the erratum</description> <title>some bug fix update</title> <type>bugfix</type> <issued>2013-11-20T02:00:00.000+02:00</issued> <solution>Few guidelines regarding the solution</solution> <summary>Updated packages that fix one bug are now available for XYZ</summary> <packages> <package> <name>libipa_hbac-1.9.2-82.11.el6_4.i686</name> </package> ... </packages> </katello_erratum> ... </katello_errata> ---- The order of the returned list of erratum isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of errata to return. If not specified all the errata are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def katello_erratum_service(self, id): """ Reference to the Katello erratum service. Use this service to view the erratum by its id. """ Service._check_types([ ('id', id, str), ]) return KatelloErratumService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.katello_erratum_service(path) return self.katello_erratum_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'EngineKatelloErrataService:%s' % self._path class ExternalHostProviderService(ExternalProviderService): """ Represents an external host provider, such as Foreman or Satellite. See https://www.theforeman.org/ for more details on Foreman. See https://access.redhat.com/products/red-hat-satellite for more details on Red Hat Satellite. """ def __init__(self, connection, path): super(ExternalHostProviderService, self).__init__(connection, path) self._certificates_service = None self._compute_resources_service = None self._discovered_hosts_service = None self._host_groups_service = None self._hosts_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get external host provider information Host provider, Foreman or Satellite, can be set as an external provider in ovirt. To see details about specific host providers attached to ovirt use this API. For example, to get the details of host provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123 .... The response will be like this: [source,xml] ---- <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"> <name>mysatellite</name> <requires_authentication>true</requires_authentication> <url>https://mysatellite.example.com</url> <username>admin</username> </external_host_provider> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait) def update( self, provider, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified external host provider in the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.ExternalHostProvider), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(provider, headers, query, wait) def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path) def compute_resources_service(self): """ """ return ExternalComputeResourcesService(self._connection, '%s/computeresources' % self._path) def discovered_hosts_service(self): """ """ return ExternalDiscoveredHostsService(self._connection, '%s/discoveredhosts' % self._path) def host_groups_service(self): """ """ return ExternalHostGroupsService(self._connection, '%s/hostgroups' % self._path) def hosts_service(self): """ """ return ExternalHostsService(self._connection, '%s/hosts' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) if path == 'computeresources': return self.compute_resources_service() if path.startswith('computeresources/'): return self.compute_resources_service().service(path[17:]) if path == 'discoveredhosts': return self.discovered_hosts_service() if path.startswith('discoveredhosts/'): return self.discovered_hosts_service().service(path[16:]) if path == 'hostgroups': return self.host_groups_service() if path.startswith('hostgroups/'): return self.host_groups_service().service(path[11:]) if path == 'hosts': return self.hosts_service() if path.startswith('hosts/'): return self.hosts_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalHostProviderService:%s' % self._path class GlusterBrickService(MeasurableService): """ This service manages a single gluster brick. """ def __init__(self, connection, path): super(GlusterBrickService, self).__init__(connection, path) self._statistics_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get details of a brick. Retrieves status details of brick from underlying gluster volume with header `All-Content` set to `true`. This is the equivalent of running `gluster volume status <volumename> <brickname> detail`. For example, to get the details of brick `234` of gluster volume `123`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/234 ---- Which will return a response body like this: [source,xml] ---- <brick id="234"> <name>host1:/rhgs/data/brick1</name> <brick_dir>/rhgs/data/brick1</brick_dir> <server_id>111</server_id> <status>up</status> <device>/dev/mapper/RHGS_vg1-lv_vmaddldisks</device> <fs_name>xfs</fs_name> <gluster_clients> <gluster_client> <bytes_read>2818417648</bytes_read> <bytes_written>1384694844</bytes_written> <client_port>1011</client_port> <host_name>client2</host_name> </gluster_client> </gluster_clients> <memory_pools> <memory_pool> <name>data-server:fd_t</name> <alloc_count>1626348</alloc_count> <cold_count>1020</cold_count> <hot_count>4</hot_count> <max_alloc>23</max_alloc> <max_stdalloc>0</max_stdalloc> <padded_size>140</padded_size> <pool_misses>0</pool_misses> </memory_pool> </memory_pools> <mnt_options>rw,seclabel,noatime,nodiratime,attr2,inode64,sunit=512,swidth=2048,noquota</mnt_options> <pid>25589</pid> <port>49155</port> </brick> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a brick. Removes a brick from the underlying gluster volume and deletes entries from database. This can be used only when removing a single brick without data migration. To remove multiple bricks and with data migration, use <<services/gluster_bricks/methods/migrate, migrate>> instead. For example, to delete brick `234` from gluster volume `123`, send a request like this: [source] ---- DELETE /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/234 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def replace( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Replaces this brick with a new one. IMPORTANT: This operation has been deprecated since version 3.5 of the engine and will be removed in the future. Use <<services/gluster_bricks/methods/add, add brick(s)>> and <<services/gluster_bricks/methods/migrate, migrate brick(s)>> instead. This method supports the following parameters: `async_`:: Indicates if the replacement should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'replace', None, headers, query, wait) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'GlusterBrickService:%s' % self._path class GlusterVolumeService(MeasurableService): """ This service manages a single gluster volume. """ def __init__(self, connection, path): super(GlusterVolumeService, self).__init__(connection, path) self._gluster_bricks_service = None self._statistics_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get the gluster volume details. For example, to get details of a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/456/glustervolumes/123 ---- This GET request will return the following output: [source,xml] ---- <gluster_volume id="123"> <name>data</name> <link href="/ovirt-engine/api/clusters/456/glustervolumes/123/glusterbricks" rel="glusterbricks"/> <disperse_count>0</disperse_count> <options> <option> <name>storage.owner-gid</name> <value>36</value> </option> <option> <name>performance.io-cache</name> <value>off</value> </option> <option> <name>cluster.data-self-heal-algorithm</name> <value>full</value> </option> </options> <redundancy_count>0</redundancy_count> <replica_count>3</replica_count> <status>up</status> <stripe_count>0</stripe_count> <transport_types> <transport_type>tcp</transport_type> </transport_types> <volume_type>replicate</volume_type> </gluster_volume> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def get_profile_statistics( self, headers=None, query=None, wait=True, **kwargs ): """ Get gluster volume profile statistics. For example, to get profile statistics for a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/getprofilestatistics ---- """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'getprofilestatistics', 'details', headers, query, wait) def rebalance( self, async_=None, fix_layout=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Rebalance the gluster volume. Rebalancing a gluster volume helps to distribute the data evenly across all the bricks. After expanding or shrinking a gluster volume (without migrating data), we need to rebalance the data among the bricks. In a non-replicated volume, all bricks should be online to perform the rebalance operation. In a replicated volume, at least one of the bricks in the replica should be online. For example, to rebalance a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/rebalance ---- This method supports the following parameters: `fix_layout`:: If set to true, rebalance will only fix the layout so that new data added to the volume is distributed across all the hosts. But it will not migrate/rebalance the existing data. Default is `false`. `force`:: Indicates if the rebalance should be force started. The rebalance command can be executed with the force option even when the older clients are connected to the cluster. However, this could lead to a data loss situation. Default is `false`. `async_`:: Indicates if the rebalance should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('fix_layout', fix_layout, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, fix_layout=fix_layout, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'rebalance', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the gluster volume. For example, to remove a volume with identifier `123` in cluster `456`, send a request like this: [source] ---- DELETE /ovirt-engine/api/clusters/456/glustervolumes/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def reset_all_options( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Resets all the options set in the gluster volume. For example, to reset all options in a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/resetalloptions ---- This method supports the following parameters: `async_`:: Indicates if the reset should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'resetalloptions', None, headers, query, wait) def reset_option( self, async_=None, force=None, option=None, headers=None, query=None, wait=True, **kwargs ): """ Resets a particular option in the gluster volume. For example, to reset a particular option `option1` in a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/resetoption ---- With the following request body: [source,xml] ---- <action> <option name="option1"/> </action> ---- This method supports the following parameters: `option`:: Option to reset. `async_`:: Indicates if the reset should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('option', option, types.Option), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, option=option, ) # Send the request and wait for the response: return self._internal_action(action, 'resetoption', None, headers, query, wait) def set_option( self, async_=None, option=None, headers=None, query=None, wait=True, **kwargs ): """ Sets a particular option in the gluster volume. For example, to set `option1` with value `value1` in a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/setoption ---- With the following request body: [source,xml] ---- <action> <option name="option1" value="value1"/> </action> ---- This method supports the following parameters: `option`:: Option to set. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('option', option, types.Option), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, option=option, ) # Send the request and wait for the response: return self._internal_action(action, 'setoption', None, headers, query, wait) def start( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Starts the gluster volume. A Gluster Volume should be started to read/write data. For example, to start a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/start ---- This method supports the following parameters: `force`:: Indicates if the volume should be force started. If a gluster volume is started already but few/all bricks are down then force start can be used to bring all the bricks up. Default is `false`. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'start', None, headers, query, wait) def start_profile( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Start profiling the gluster volume. For example, to start profiling a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/startprofile ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'startprofile', None, headers, query, wait) def stop( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Stops the gluster volume. Stopping a volume will make its data inaccessible. For example, to stop a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/stop ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'stop', None, headers, query, wait) def stop_profile( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Stop profiling the gluster volume. For example, to stop profiling a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/stopprofile ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'stopprofile', None, headers, query, wait) def stop_rebalance( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Stop rebalancing the gluster volume. For example, to stop rebalancing a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/stoprebalance ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'stoprebalance', None, headers, query, wait) def gluster_bricks_service(self): """ Reference to a service managing gluster bricks. """ return GlusterBricksService(self._connection, '%s/glusterbricks' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'glusterbricks': return self.gluster_bricks_service() if path.startswith('glusterbricks/'): return self.gluster_bricks_service().service(path[14:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'GlusterVolumeService:%s' % self._path class HostService(MeasurableService): """ A service to manage a host. """ def __init__(self, connection, path): super(HostService, self).__init__(connection, path) self._affinity_labels_service = None self._devices_service = None self._external_network_provider_configurations_service = None self._fence_agents_service = None self._hooks_service = None self._katello_errata_service = None self._network_attachments_service = None self._nics_service = None self._numa_nodes_service = None self._permissions_service = None self._statistics_service = None self._storage_service = None self._storage_connection_extensions_service = None self._tags_service = None self._unmanaged_networks_service = None def activate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Activates the host for use, for example to run virtual machines. This method supports the following parameters: `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait) def approve( self, activate=None, async_=None, cluster=None, host=None, reboot=None, headers=None, query=None, wait=True, **kwargs ): """ 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. This method supports the following parameters: `host`:: The host to approve. `cluster`:: The cluster where the host will be added after it is approved. `async_`:: Indicates if the approval should be performed asynchronously. `activate`:: When set to 'true', this host will be activated after its approval completes. When set to 'false' the host will remain in 'maintenance' status after its approval. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after approval. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('host', host, types.Host), ('reboot', reboot, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, cluster=cluster, host=host, reboot=reboot, ) # Send the request and wait for the response: return self._internal_action(action, 'approve', None, headers, query, wait) def commit_net_config( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ 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: [source] ---- POST /ovirt-engine/api/hosts/123/commitnetconfig ---- With a request body like this: [source,xml] ---- <action/> ---- IMPORTANT: Since {engine-name} 4.3, it is possible to also specify `commit_on_success` in the <<services/host/methods/setup_networks, setupnetworks>> request, in which case the new configuration is automatically saved in the {hypervisor-name} upon completing the setup and re-establishing connectivity between the {hypervisor-name} and {engine-name}, and without waiting for a separate <<services/host/methods/commit_net_config, commitnetconfig>> request. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'commitnetconfig', None, headers, query, wait) def copy_host_networks( self, async_=None, source_host=None, headers=None, query=None, wait=True, **kwargs ): """ Copy the network configuration of the specified host to current host. IMPORTANT: Any network attachments that are not present on the source host will be erased from the target host by the copy operation. To copy networks from another host, send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/copyhostnetworks ---- With a request body like this: [source,xml] ---- <action> <source_host id="456"/> </action> ---- This method supports the following parameters: `source_host`:: The host to copy networks from. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('source_host', source_host, types.Host), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, source_host=source_host, ) # Send the request and wait for the response: return self._internal_action(action, 'copyhostnetworks', None, headers, query, wait) def deactivate( self, async_=None, reason=None, stop_gluster_service=None, headers=None, query=None, wait=True, **kwargs ): """ Deactivates the host to perform maintenance tasks. This method supports the following parameters: `async_`:: Indicates if the deactivation should be performed asynchronously. `stop_gluster_service`:: 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`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('reason', reason, str), ('stop_gluster_service', stop_gluster_service, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, reason=reason, stop_gluster_service=stop_gluster_service, ) # Send the request and wait for the response: return self._internal_action(action, 'deactivate', None, headers, query, wait) def discover_iscsi( self, async_=None, iscsi=None, headers=None, query=None, wait=True, **kwargs ): """ Discovers iSCSI targets on the host, using the initiator details. Returns a list of IscsiDetails objects containing the discovered data. For example, to discover iSCSI targets available in `myiscsi.example.com`, from host `123`, send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/discoveriscsi ---- With a request body like this: [source,xml] ---- <action> <iscsi> <address>myiscsi.example.com</address> </iscsi> </action> ---- The result will be like this: [source,xml] ---- <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> ---- IMPORTANT: When using this method to discover iscsi targets, you can use an FQDN or an IP address, but you must use the iscsi details from the discovered targets results to log in using the iscsilogin method. This method supports the following parameters: `iscsi`:: The target iSCSI device. `async_`:: Indicates if the discovery should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('iscsi', iscsi, types.IscsiDetails), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, iscsi=iscsi, ) # Send the request and wait for the response: return self._internal_action(action, 'discoveriscsi', 'discovered_targets', headers, query, wait) def enroll_certificate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Enrolls the certificate of the host. Useful in case you get a warning that it is about to expire or has already expired. This method supports the following parameters: `async_`:: Indicates if the enrollment should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'enrollcertificate', None, headers, query, wait) def fence( self, async_=None, fence_type=None, maintenance_after_restart=None, headers=None, query=None, wait=True, **kwargs ): """ Controls the host's power management device. For example, to start the host. This can be done via: [source] ---- #!/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" ---- This method supports the following parameters: `async_`:: Indicates if the fencing should be performed asynchronously. `maintenance_after_restart`:: Indicates if host should be put into maintenance after restart. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('fence_type', fence_type, str), ('maintenance_after_restart', maintenance_after_restart, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, fence_type=fence_type, maintenance_after_restart=maintenance_after_restart, ) # Send the request and wait for the response: return self._internal_action(action, 'fence', 'power_management', headers, query, wait) def force_select_spm( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ To manually set a host as the storage pool manager (SPM). [source] ---- POST /ovirt-engine/api/hosts/123/forceselectspm ---- With a request body like this: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'forceselectspm', None, headers, query, wait) def get( self, all_content=None, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the host details. [source] ---- GET /ovirt-engine/api/hosts/123 ---- This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `all_content`:: 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. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def install( self, activate=None, async_=None, deploy_hosted_engine=None, host=None, image=None, reboot=None, root_password=None, ssh=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ 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: [source,bash] ---- 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: [source,bash] ---- 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" "deploy_hosted_engine" : "true" } ' \ "https://engine.example.com/ovirt-engine/api/hosts/123" ---- IMPORTANT: Since version 4.1.2 of the engine, when a host is reinstalled we override the host firewall definitions by default. This method supports the following parameters: `activate`:: When set to 'true', this host will be activated after its installation completes. When set to 'false' the host will remain in 'maintenance' status after its installation. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after install. `root_password`:: The password of the `root` user used to connect to the host via SSH. `ssh`:: The SSH details used to connect to the host. `host`:: The `override_iptables` property is used to indicate if the firewall configuration should be replaced by the default one. `image`:: When installing {hypervisor-name}, an ISO image file is required. `async_`:: Indicates if the installation should be performed asynchronously. `deploy_hosted_engine`:: When set to `true` this host will also deploy the self-hosted engine components. A missing value is treated as `true` i.e deploy. Omitting this parameter means `false` and will not perform any operation in the self-hosted engine area. `undeploy_hosted_engine`:: When set to `true` this host will 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 not perform any operation in the self-hosted engine area. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('host', host, types.Host), ('image', image, str), ('reboot', reboot, bool), ('root_password', root_password, str), ('ssh', ssh, types.Ssh), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, deploy_hosted_engine=deploy_hosted_engine, host=host, image=image, reboot=reboot, root_password=root_password, ssh=ssh, undeploy_hosted_engine=undeploy_hosted_engine, ) # Send the request and wait for the response: return self._internal_action(action, 'install', None, headers, query, wait) def iscsi_discover( self, async_=None, iscsi=None, headers=None, query=None, wait=True, **kwargs ): """ This method has been deprecated since Engine version 4.4.6. DiscoverIscsi should be used instead. Discovers iSCSI targets on the host, using the initiator details. Returns an array of strings containing the discovered data. For example, to discover iSCSI targets available in `myiscsi.example.com`, from host `123`, send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/iscsidiscover ---- With a request body like this: [source,xml] ---- <action> <iscsi> <address>myiscsi.example.com</address> </iscsi> </action> ---- This method supports the following parameters: `iscsi`:: The target iSCSI device. `async_`:: Indicates if the discovery should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('iscsi', iscsi, types.IscsiDetails), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, iscsi=iscsi, ) # Send the request and wait for the response: return self._internal_action(action, 'iscsidiscover', 'iscsi_targets', headers, query, wait) def iscsi_login( self, async_=None, iscsi=None, headers=None, query=None, wait=True, **kwargs ): """ Login to iSCSI targets on the host, using the target details. IMPORTANT: When using this method to log in, you must use the iscsi details from the discovered targets results in the discoveriscsi method. This method supports the following parameters: `iscsi`:: The target iSCSI device. `async_`:: Indicates if the login should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('iscsi', iscsi, types.IscsiDetails), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, iscsi=iscsi, ) # Send the request and wait for the response: return self._internal_action(action, 'iscsilogin', None, headers, query, wait) def refresh( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Refresh the host devices and capabilities. This method supports the following parameters: `async_`:: Indicates if the refresh should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'refresh', None, headers, query, wait) def remove( self, force=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the host from the system. [source] ---- #!/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" ---- This method supports the following parameters: `force`:: Indicates that the host should be removed even if it is non-responsive, or if it is part of a Gluster Storage cluster and has volume bricks on it. `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('force', force, bool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if force is not None: force = Writer.render_boolean(force) query['force'] = force if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def setup_networks( self, async_=None, check_connectivity=None, commit_on_success=None, connectivity_timeout=None, modified_bonds=None, modified_labels=None, modified_network_attachments=None, removed_bonds=None, removed_labels=None, removed_network_attachments=None, synchronized_network_attachments=None, headers=None, query=None, wait=True, **kwargs ): """ 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: [source] ---- #!/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> <ip_address_assignment> <assignment_method>static</assignment_method> <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: [source,xml] ---- <options name="mode" value="4"/> <options name="miimon" value="100"/> <ip address="192.168.122.10" netmask="255.255.255.0"/> ---- The same thing can be done using the Python SDK with the following code: [source,python] ---- # 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 <<services/host/methods/commit_net_config, commitnetconfig>>. IMPORTANT: Since {engine-name} 4.3, it is possible to also specify `commit_on_success` in the <<services/host/methods/setup_networks, setupnetworks>> request, in which case the new configuration is automatically saved in the {hypervisor-name} upon completing the setup and re-establishing connectivity between the {hypervisor-name} and {engine-name}, and without waiting for a separate <<services/host/methods/commit_net_config, commitnetconfig>> request. This method supports the following parameters: `synchronized_network_attachments`:: A list of network attachments that will be synchronized. `commit_on_success`:: Specifies whether to automatically save the configuration in the {hypervisor-name} upon completing the setup and re-establishing connectivity between the {hypervisor-name} and {engine-name}, and without waiting for a separate <<services/host/methods/commit_net_config, commitnetconfig>> request. The default value is `false`, which means that the configuration will not be saved automatically. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('check_connectivity', check_connectivity, bool), ('commit_on_success', commit_on_success, bool), ('connectivity_timeout', connectivity_timeout, int), ('modified_bonds', modified_bonds, list), ('modified_labels', modified_labels, list), ('modified_network_attachments', modified_network_attachments, list), ('removed_bonds', removed_bonds, list), ('removed_labels', removed_labels, list), ('removed_network_attachments', removed_network_attachments, list), ('synchronized_network_attachments', synchronized_network_attachments, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, check_connectivity=check_connectivity, commit_on_success=commit_on_success, connectivity_timeout=connectivity_timeout, modified_bonds=modified_bonds, modified_labels=modified_labels, modified_network_attachments=modified_network_attachments, removed_bonds=removed_bonds, removed_labels=removed_labels, removed_network_attachments=removed_network_attachments, synchronized_network_attachments=synchronized_network_attachments, ) # Send the request and wait for the response: return self._internal_action(action, 'setupnetworks', None, headers, query, wait) def sync_all_networks( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ To synchronize all networks on the host, send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/syncallnetworks ---- With a request body like this: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'syncallnetworks', None, headers, query, wait) def unregistered_storage_domains_discover( self, async_=None, iscsi=None, headers=None, query=None, wait=True, **kwargs ): """ Discovers the block Storage Domains which are candidates to be imported to the setup. For FCP no arguments are required. This method supports the following parameters: `async_`:: Indicates if the discovery should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('iscsi', iscsi, types.IscsiDetails), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, iscsi=iscsi, ) # Send the request and wait for the response: return self._internal_action(action, 'unregisteredstoragedomainsdiscover', 'storage_domains', headers, query, wait) def update( self, host, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the host properties. For example, to update a the kernel command line of a host send a request like this: [source] ---- PUT /ovirt-engine/api/hosts/123 ---- With request body like this: [source, xml] ---- <host> <os> <custom_kernel_cmdline>vfio_iommu_type1.allow_unsafe_interrupts=1</custom_kernel_cmdline> </os> </host> ---- """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(host, headers, query, wait) def upgrade( self, async_=None, image=None, reboot=None, timeout=None, headers=None, query=None, wait=True, **kwargs ): """ Upgrades VDSM and selected software on the host. This method supports the following parameters: `image`:: This property is no longer relevant, since Vintage Node is no longer supported, and has been deprecated. `reboot`:: Indicates if the host should be rebooted after the upgrade. By default the host is rebooted. NOTE: This parameter is ignored for {hypervisor-name}, which is always rebooted after the upgrade. `async_`:: Indicates if the upgrade should be performed asynchronously. `timeout`:: Upgrade timeout. The maximum time to wait for upgrade to finish in minutes. Default value is specified by `ANSIBLE_PLAYBOOK_EXEC_DEFAULT_TIMEOUT` configration option. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('image', image, str), ('reboot', reboot, bool), ('timeout', timeout, int), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, image=image, reboot=reboot, timeout=timeout, ) # Send the request and wait for the response: return self._internal_action(action, 'upgrade', None, headers, query, wait) def upgrade_check( self, headers=None, query=None, wait=True, **kwargs ): """ 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 <<services/host/methods/upgrade, upgrade>> host action. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'upgradecheck', None, headers, query, wait) def approve_using_root_password( self, activate=None, async_=None, cluster=None, host=None, reboot=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `host`:: The host to approve. `cluster`:: The cluster where the host will be added after it is approved. `async_`:: Indicates if the approval should be performed asynchronously. `activate`:: When set to 'true', this host will be activated after its approval completes. When set to 'false' the host will remain in 'maintenance' status after its approval. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after approval. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('host', host, types.Host), ('reboot', reboot, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, cluster=cluster, host=host, reboot=reboot, ) # Send the request and wait for the response: return self._internal_action(action, 'approve', None, headers, query, wait) def install_using_root_password( self, activate=None, async_=None, deploy_hosted_engine=None, host=None, image=None, reboot=None, root_password=None, ssh=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ 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. This method supports the following parameters: `activate`:: When set to 'true', this host will be activated after its installation completes. When set to 'false' the host will remain in 'maintenance' status after its installation. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after install. `root_password`:: The password of the `root` user used to connect to the host via SSH. `ssh`:: The SSH details used to connect to the host. `host`:: The `override_iptables` property is used to indicate if the firewall configuration should be replaced by the default one. `image`:: When installing {hypervisor-name}, an ISO image file is required. `async_`:: Indicates if the installation should be performed asynchronously. `deploy_hosted_engine`:: When set to `true` this host will also deploy the self-hosted engine components. A missing value is treated as `true` i.e deploy. Omitting this parameter means `false` and will not perform any operation in the self-hosted engine area. `undeploy_hosted_engine`:: When set to `true` this host will 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 not perform any operation in the self-hosted engine area. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('host', host, types.Host), ('image', image, str), ('reboot', reboot, bool), ('root_password', root_password, str), ('ssh', ssh, types.Ssh), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, deploy_hosted_engine=deploy_hosted_engine, host=host, image=image, reboot=reboot, root_password=root_password, ssh=ssh, undeploy_hosted_engine=undeploy_hosted_engine, ) # Send the request and wait for the response: return self._internal_action(action, 'install', None, headers, query, wait) def update_using_root_password( self, host, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified host in the system. This is deprecated and is provided only for backwards compatibility. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(host, headers, query, wait) def approve_using_ssh( self, activate=None, async_=None, cluster=None, host=None, reboot=None, headers=None, query=None, wait=True, **kwargs ): """ Approve the specified host to be added to the engine by using ssh authentication. This occurs when the host registers itself with the engine. This method supports the following parameters: `host`:: The host to approve. `cluster`:: The cluster where the host will be added after it is approved. `async_`:: Indicates if the approval should be performed asynchronously. `activate`:: When set to 'true', this host will be activated after its approval completes. When set to 'false' the host will remain in 'maintenance' status after its approval. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after approval. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('host', host, types.Host), ('reboot', reboot, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, cluster=cluster, host=host, reboot=reboot, ) # Send the request and wait for the response: return self._internal_action(action, 'approve', None, headers, query, wait) def install_using_ssh( self, activate=None, async_=None, deploy_hosted_engine=None, host=None, image=None, reboot=None, root_password=None, ssh=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ Install VDSM and other packages required to get the host ready to be used in the engine providing the SSH password. This method supports the following parameters: `activate`:: When set to 'true', this host will be activated after its installation completes. When set to 'false' the host will remain in 'maintenance' status after its installation. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after install. `root_password`:: The password of the `root` user used to connect to the host via SSH. `ssh`:: The SSH details used to connect to the host. `host`:: The `override_iptables` property is used to indicate if the firewall configuration should be replaced by the default one. `image`:: When installing {hypervisor-name}, an ISO image file is required. `async_`:: Indicates if the installation should be performed asynchronously. `deploy_hosted_engine`:: When set to `true` this host will also deploy the self-hosted engine components. A missing value is treated as `true` i.e deploy. Omitting this parameter means `false` and will not perform any operation in the self-hosted engine area. `undeploy_hosted_engine`:: When set to `true` this host will 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 not perform any operation in the self-hosted engine area. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('host', host, types.Host), ('image', image, str), ('reboot', reboot, bool), ('root_password', root_password, str), ('ssh', ssh, types.Ssh), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, deploy_hosted_engine=deploy_hosted_engine, host=host, image=image, reboot=reboot, root_password=root_password, ssh=ssh, undeploy_hosted_engine=undeploy_hosted_engine, ) # Send the request and wait for the response: return self._internal_action(action, 'install', None, headers, query, wait) def update_using_ssh( self, host, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the specified host in the system. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(host, headers, query, wait) def affinity_labels_service(self): """ List of scheduling labels assigned to this host. """ return AssignedAffinityLabelsService(self._connection, '%s/affinitylabels' % self._path) def devices_service(self): """ A reference to the host devices service. Use this service to view the devices of the host object. """ return HostDevicesService(self._connection, '%s/devices' % self._path) def external_network_provider_configurations_service(self): """ External network providers provisioned by the system on the host. """ return ExternalNetworkProviderConfigurationsService(self._connection, '%s/externalnetworkproviderconfigurations' % self._path) def fence_agents_service(self): """ A reference to the fence agents service. Use this service to manage fence and power management agents on the host object. """ return FenceAgentsService(self._connection, '%s/fenceagents' % self._path) def hooks_service(self): """ A reference to the host hooks service. Use this service to view the hooks available in the host object. """ return HostHooksService(self._connection, '%s/hooks' % self._path) def katello_errata_service(self): """ A reference to the service that can show the applicable errata available on the host. This information is taken from Katello. """ return KatelloErrataService(self._connection, '%s/katelloerrata' % self._path) def network_attachments_service(self): """ A reference to the network attachments service. You can use this service to attach Logical networks to host interfaces. """ return NetworkAttachmentsService(self._connection, '%s/networkattachments' % self._path) def nics_service(self): """ A reference to the service that manages the network interface devices on the host. """ return HostNicsService(self._connection, '%s/nics' % self._path) def numa_nodes_service(self): """ A reference to the service that manage NUMA nodes for the host. """ return HostNumaNodesService(self._connection, '%s/numanodes' % self._path) def permissions_service(self): """ A reference to the host permission service. Use this service to manage permissions on the host object. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def storage_service(self): """ A reference to the service that manages the host's storage. """ return HostStorageService(self._connection, '%s/storage' % self._path) def storage_connection_extensions_service(self): """ A reference to storage connection extensions. """ return StorageServerConnectionExtensionsService(self._connection, '%s/storageconnectionextensions' % self._path) def tags_service(self): """ A reference to the host tags service. Use this service to manage tags on the host object. """ return AssignedTagsService(self._connection, '%s/tags' % self._path) def unmanaged_networks_service(self): """ A reference to unmanaged networks. """ return UnmanagedNetworksService(self._connection, '%s/unmanagednetworks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'affinitylabels': return self.affinity_labels_service() if path.startswith('affinitylabels/'): return self.affinity_labels_service().service(path[15:]) if path == 'devices': return self.devices_service() if path.startswith('devices/'): return self.devices_service().service(path[8:]) if path == 'externalnetworkproviderconfigurations': return self.external_network_provider_configurations_service() if path.startswith('externalnetworkproviderconfigurations/'): return self.external_network_provider_configurations_service().service(path[38:]) if path == 'fenceagents': return self.fence_agents_service() if path.startswith('fenceagents/'): return self.fence_agents_service().service(path[12:]) if path == 'hooks': return self.hooks_service() if path.startswith('hooks/'): return self.hooks_service().service(path[6:]) if path == 'katelloerrata': return self.katello_errata_service() if path.startswith('katelloerrata/'): return self.katello_errata_service().service(path[14:]) if path == 'networkattachments': return self.network_attachments_service() if path.startswith('networkattachments/'): return self.network_attachments_service().service(path[19:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) if path == 'numanodes': return self.numa_nodes_service() if path.startswith('numanodes/'): return self.numa_nodes_service().service(path[10:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) if path == 'storage': return self.storage_service() if path.startswith('storage/'): return self.storage_service().service(path[8:]) if path == 'storageconnectionextensions': return self.storage_connection_extensions_service() if path.startswith('storageconnectionextensions/'): return self.storage_connection_extensions_service().service(path[28:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) if path == 'unmanagednetworks': return self.unmanaged_networks_service() if path.startswith('unmanagednetworks/'): return self.unmanaged_networks_service().service(path[18:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'HostService:%s' % self._path class HostNicService(MeasurableService): """ A service to manage a network interface of a host. """ def __init__(self, connection, path): super(HostNicService, self).__init__(connection, path) self._link_layer_discovery_protocol_elements_service = None self._network_attachments_service = None self._network_labels_service = None self._statistics_service = None self._virtual_function_allowed_labels_service = None self._virtual_function_allowed_networks_service = None def get( self, all_content=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `all_content`:: Indicates if all of the attributes of the host network interface should be included in the response. By default the following attributes are excluded: - `virtual_functions_configuration` For example, to retrieve the complete representation network interface '456' of host '123': .... GET /ovirt-engine/api/hosts/123/nics/456?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. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def update_virtual_functions_configuration( self, async_=None, virtual_functions_configuration=None, headers=None, query=None, wait=True, **kwargs ): """ The action updates virtual function configuration in case the current resource represents an SR-IOV enabled NIC. The input should be consisted of at least one of the following properties: - `allNetworksAllowed` - `numberOfVirtualFunctions` Please see the `HostNicVirtualFunctionsConfiguration` type for the meaning of the properties. This method supports the following parameters: `async_`:: Indicates if the update should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('virtual_functions_configuration', virtual_functions_configuration, types.HostNicVirtualFunctionsConfiguration), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, virtual_functions_configuration=virtual_functions_configuration, ) # Send the request and wait for the response: return self._internal_action(action, 'updatevirtualfunctionsconfiguration', None, headers, query, wait) def link_layer_discovery_protocol_elements_service(self): """ A reference to information elements received by LLDP on the NIC. """ return LinkLayerDiscoveryProtocolService(self._connection, '%s/linklayerdiscoveryprotocolelements' % self._path) def network_attachments_service(self): """ Reference to the service that manages the network attachments assigned to this network interface. """ return NetworkAttachmentsService(self._connection, '%s/networkattachments' % self._path) def network_labels_service(self): """ Reference to the service that manages the network labels assigned to this network interface. """ return NetworkLabelsService(self._connection, '%s/networklabels' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def virtual_function_allowed_labels_service(self): """ Retrieves sub-collection resource of network labels that are allowed on an the virtual functions in case that the current resource represents an SR-IOV physical function NIC. """ return NetworkLabelsService(self._connection, '%s/virtualfunctionallowedlabels' % self._path) def virtual_function_allowed_networks_service(self): """ Retrieves sub-collection resource of networks that are allowed on an the virtual functions in case that the current resource represents an SR-IOV physical function NIC. """ return VirtualFunctionAllowedNetworksService(self._connection, '%s/virtualfunctionallowednetworks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'linklayerdiscoveryprotocolelements': return self.link_layer_discovery_protocol_elements_service() if path.startswith('linklayerdiscoveryprotocolelements/'): return self.link_layer_discovery_protocol_elements_service().service(path[35:]) if path == 'networkattachments': return self.network_attachments_service() if path.startswith('networkattachments/'): return self.network_attachments_service().service(path[19:]) if path == 'networklabels': return self.network_labels_service() if path.startswith('networklabels/'): return self.network_labels_service().service(path[14:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) if path == 'virtualfunctionallowedlabels': return self.virtual_function_allowed_labels_service() if path.startswith('virtualfunctionallowedlabels/'): return self.virtual_function_allowed_labels_service().service(path[29:]) if path == 'virtualfunctionallowednetworks': return self.virtual_function_allowed_networks_service() if path.startswith('virtualfunctionallowednetworks/'): return self.virtual_function_allowed_networks_service().service(path[31:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'HostNicService:%s' % self._path class HostNumaNodeService(MeasurableService): """ """ def __init__(self, connection, path): super(HostNumaNodeService, self).__init__(connection, path) self._statistics_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'HostNumaNodeService:%s' % self._path
View Source
class AffinityGroupService(Service): """ This service manages a single affinity group. """ def __init__(self, connection, path): super(AffinityGroupService, self).__init__(connection, path) self._host_labels_service = None self._hosts_service = None self._vm_labels_service = None self._vms_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieve the affinity group details. [source,xml] ---- <affinity_group id="00000000-0000-0000-0000-000000000000"> <name>AF_GROUP_001</name> <cluster id="00000000-0000-0000-0000-000000000000"/> <positive>true</positive> <enforcing>true</enforcing> </affinity_group> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the affinity group. [source] ---- DELETE /ovirt-engine/api/clusters/000-000/affinitygroups/123-456 ---- This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, group, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the affinity group. This method supports the following parameters: `group`:: The affinity group. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('group', group, types.AffinityGroup), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(group, headers, query, wait) def host_labels_service(self): """ Returns a reference to the service that manages the list of all host labels attached to this affinity group. """ return AffinityGroupHostLabelsService(self._connection, '%s/hostlabels' % self._path) def hosts_service(self): """ Returns a reference to the service that manages the list of all hosts attached to this affinity group. """ return AffinityGroupHostsService(self._connection, '%s/hosts' % self._path) def vm_labels_service(self): """ Returns a reference to the service that manages the list of all virtual machine labels attached to this affinity group. """ return AffinityGroupVmLabelsService(self._connection, '%s/vmlabels' % self._path) def vms_service(self): """ Returns a reference to the service that manages the list of all virtual machines attached to this affinity group. """ return AffinityGroupVmsService(self._connection, '%s/vms' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'hostlabels': return self.host_labels_service() if path.startswith('hostlabels/'): return self.host_labels_service().service(path[11:]) if path == 'hosts': return self.hosts_service() if path.startswith('hosts/'): return self.hosts_service().service(path[6:]) if path == 'vmlabels': return self.vm_labels_service() if path.startswith('vmlabels/'): return self.vm_labels_service().service(path[9:]) if path == 'vms': return self.vms_service() if path.startswith('vms/'): return self.vms_service().service(path[4:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityGroupService:%s' % self._path
This service manages a single affinity group.
View Source
def __init__(self, connection, path): super(AffinityGroupService, self).__init__(connection, path) self._host_labels_service = None self._hosts_service = None self._vm_labels_service = None self._vms_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieve the affinity group details. [source,xml] ---- <affinity_group id="00000000-0000-0000-0000-000000000000"> <name>AF_GROUP_001</name> <cluster id="00000000-0000-0000-0000-000000000000"/> <positive>true</positive> <enforcing>true</enforcing> </affinity_group> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieve the affinity group details.
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the affinity group. [source] ---- DELETE /ovirt-engine/api/clusters/000-000/affinitygroups/123-456 ---- This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove the affinity group.
[source]
DELETE /ovirt-engine/api/clusters/000-000/affinitygroups/123-456
This method supports the following parameters:
async_:: Indicates if the removal should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, group, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the affinity group. This method supports the following parameters: `group`:: The affinity group. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('group', group, types.AffinityGroup), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(group, headers, query, wait)
Update the affinity group.
This method supports the following parameters:
group:: The affinity group.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def host_labels_service(self): """ Returns a reference to the service that manages the list of all host labels attached to this affinity group. """ return AffinityGroupHostLabelsService(self._connection, '%s/hostlabels' % self._path)
Returns a reference to the service that manages the list of all host labels attached to this affinity group.
View Source
def hosts_service(self): """ Returns a reference to the service that manages the list of all hosts attached to this affinity group. """ return AffinityGroupHostsService(self._connection, '%s/hosts' % self._path)
Returns a reference to the service that manages the list of all hosts attached to this affinity group.
View Source
def vm_labels_service(self): """ Returns a reference to the service that manages the list of all virtual machine labels attached to this affinity group. """ return AffinityGroupVmLabelsService(self._connection, '%s/vmlabels' % self._path)
Returns a reference to the service that manages the list of all virtual machine labels attached to this affinity group.
View Source
def vms_service(self): """ Returns a reference to the service that manages the list of all virtual machines attached to this affinity group. """ return AffinityGroupVmsService(self._connection, '%s/vms' % self._path)
Returns a reference to the service that manages the list of all virtual machines attached to this affinity group.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'hostlabels': return self.host_labels_service() if path.startswith('hostlabels/'): return self.host_labels_service().service(path[11:]) if path == 'hosts': return self.hosts_service() if path.startswith('hosts/'): return self.hosts_service().service(path[6:]) if path == 'vmlabels': return self.vm_labels_service() if path.startswith('vmlabels/'): return self.vm_labels_service().service(path[9:]) if path == 'vms': return self.vms_service() if path.startswith('vms/'): return self.vms_service().service(path[4:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityGroupHostService(Service): """ This service manages a single host to affinity group assignment. """ def __init__(self, connection, path): super(AffinityGroupHostService, self).__init__(connection, path) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove host from the affinity group. This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityGroupHostService:%s' % self._path
This service manages a single host to affinity group assignment.
View Source
def __init__(self, connection, path): super(AffinityGroupHostService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove host from the affinity group. This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove host from the affinity group.
This method supports the following parameters:
async_:: Indicates if the removal should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityGroupHostLabelService(Service): """ This service manages a single host label assigned to an affinity group. """ def __init__(self, connection, path): super(AffinityGroupHostLabelService, self).__init__(connection, path) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove this label from the affinity group. This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityGroupHostLabelService:%s' % self._path
This service manages a single host label assigned to an affinity group.
View Source
def __init__(self, connection, path): super(AffinityGroupHostLabelService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove this label from the affinity group. This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove this label from the affinity group.
This method supports the following parameters:
async_:: Indicates if the removal should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityGroupHostLabelsService(Service): """ This service manages a collection of all host labels assigned to an affinity group. """ def __init__(self, connection, path): super(AffinityGroupHostLabelsService, self).__init__(connection, path) self._label_service = None def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Adds a host label to the affinity group. For example, to add the label `789` to the affinity group `456` of cluster `123`, send a request like this: .... POST /ovirt-engine/api/clusters/123/affinitygroups/456/hostlabels .... With the following body: [source,xml] ---- <affinity_label id="789"/> ---- This method supports the following parameters: `label`:: The AffinityLabel object to add to the affinity group. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all host labels assigned to this affinity group. The order of the returned labels isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of host labels to return. If not specified, all the labels are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def label_service(self, id): """ Access the service that manages the host label assignment to this affinity group. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupHostLabelService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityGroupHostLabelsService:%s' % self._path
This service manages a collection of all host labels assigned to an affinity group.
View Source
def __init__(self, connection, path): super(AffinityGroupHostLabelsService, self).__init__(connection, path) self._label_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Adds a host label to the affinity group. For example, to add the label `789` to the affinity group `456` of cluster `123`, send a request like this: .... POST /ovirt-engine/api/clusters/123/affinitygroups/456/hostlabels .... With the following body: [source,xml] ---- <affinity_label id="789"/> ---- This method supports the following parameters: `label`:: The AffinityLabel object to add to the affinity group. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait)
Adds a host label to the affinity group.
For example, to add the label 789 to the affinity group 456 of cluster 123,
send a request like this:
....
POST /ovirt-engine/api/clusters/123/affinitygroups/456/hostlabels
....
With the following body:
[source,xml]
This method supports the following parameters:
label:: The AffinityLabel object to add to the affinity group.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all host labels assigned to this affinity group. The order of the returned labels isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of host labels to return. If not specified, all the labels are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List all host labels assigned to this affinity group. The order of the returned labels isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of host labels to return.
If not specified, all the labels are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def label_service(self, id): """ Access the service that manages the host label assignment to this affinity group. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupHostLabelService(self._connection, '%s/%s' % (self._path, id))
Access the service that manages the host label assignment to this affinity group.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityGroupHostsService(Service): """ This service manages a collection of all hosts assigned to an affinity group. """ def __init__(self, connection, path): super(AffinityGroupHostsService, self).__init__(connection, path) self._host_service = None def add( self, host, headers=None, query=None, wait=True, **kwargs ): """ Adds a host to the affinity group. For example, to add the host `789` to the affinity group `456` of cluster `123`, send a request like this: .... POST /ovirt-engine/api/clusters/123/affinitygroups/456/hosts .... With the following body: [source,xml] ---- <host id="789"/> ---- This method supports the following parameters: `host`:: The host to be added to the affinity group. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(host, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all hosts assigned to this affinity group. The order of the returned hosts isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of hosts to return. If not specified, all the hosts are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def host_service(self, id): """ Access the service that manages the host assignment to this affinity group. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupHostService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityGroupHostsService:%s' % self._path
This service manages a collection of all hosts assigned to an affinity group.
View Source
def __init__(self, connection, path): super(AffinityGroupHostsService, self).__init__(connection, path) self._host_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, host, headers=None, query=None, wait=True, **kwargs ): """ Adds a host to the affinity group. For example, to add the host `789` to the affinity group `456` of cluster `123`, send a request like this: .... POST /ovirt-engine/api/clusters/123/affinitygroups/456/hosts .... With the following body: [source,xml] ---- <host id="789"/> ---- This method supports the following parameters: `host`:: The host to be added to the affinity group. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(host, headers, query, wait)
Adds a host to the affinity group.
For example, to add the host 789 to the affinity group 456 of cluster 123, send a request like
this:
....
POST /ovirt-engine/api/clusters/123/affinitygroups/456/hosts
....
With the following body:
[source,xml]
This method supports the following parameters:
host:: The host to be added to the affinity group.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all hosts assigned to this affinity group. The order of the returned hosts isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of hosts to return. If not specified, all the hosts are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List all hosts assigned to this affinity group. The order of the returned hosts isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of hosts to return. If not specified, all the hosts are
returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def host_service(self, id): """ Access the service that manages the host assignment to this affinity group. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupHostService(self._connection, '%s/%s' % (self._path, id))
Access the service that manages the host assignment to this affinity group.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityGroupVmService(Service): """ This service manages a single virtual machine to affinity group assignment. """ def __init__(self, connection, path): super(AffinityGroupVmService, self).__init__(connection, path) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove this virtual machine from the affinity group. This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityGroupVmService:%s' % self._path
This service manages a single virtual machine to affinity group assignment.
View Source
def __init__(self, connection, path): super(AffinityGroupVmService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove this virtual machine from the affinity group. This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove this virtual machine from the affinity group.
This method supports the following parameters:
async_:: Indicates if the removal should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityGroupVmLabelService(Service): """ This service manages a single virtual machine label assigned to an affinity group. """ def __init__(self, connection, path): super(AffinityGroupVmLabelService, self).__init__(connection, path) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove this label from the affinity group. This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityGroupVmLabelService:%s' % self._path
This service manages a single virtual machine label assigned to an affinity group.
View Source
def __init__(self, connection, path): super(AffinityGroupVmLabelService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove this label from the affinity group. This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove this label from the affinity group.
This method supports the following parameters:
async_:: Indicates if the removal should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityGroupVmLabelsService(Service): """ This service manages a collection of all virtual machine labels assigned to an affinity group. """ def __init__(self, connection, path): super(AffinityGroupVmLabelsService, self).__init__(connection, path) self._label_service = None def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Adds a virtual machine label to the affinity group. For example, to add the label `789` to the affinity group `456` of cluster `123`, send a request like this: .... POST /ovirt-engine/api/clusters/123/affinitygroups/456/vmlabels .... With the following body: [source,xml] ---- <affinity_label id="789"/> ---- This method supports the following parameters: `label`:: The AffinityLabel object to add to the affinity group. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all virtual machine labels assigned to this affinity group. The order of the returned labels isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of virtual machine labels to return. If not specified, all the labels are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def label_service(self, id): """ Access the service that manages the virtual machine label assignment to this affinity group. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupVmLabelService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityGroupVmLabelsService:%s' % self._path
This service manages a collection of all virtual machine labels assigned to an affinity group.
View Source
def __init__(self, connection, path): super(AffinityGroupVmLabelsService, self).__init__(connection, path) self._label_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Adds a virtual machine label to the affinity group. For example, to add the label `789` to the affinity group `456` of cluster `123`, send a request like this: .... POST /ovirt-engine/api/clusters/123/affinitygroups/456/vmlabels .... With the following body: [source,xml] ---- <affinity_label id="789"/> ---- This method supports the following parameters: `label`:: The AffinityLabel object to add to the affinity group. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait)
Adds a virtual machine label to the affinity group.
For example, to add the label 789 to the affinity group 456 of cluster 123,
send a request like this:
....
POST /ovirt-engine/api/clusters/123/affinitygroups/456/vmlabels
....
With the following body:
[source,xml]
This method supports the following parameters:
label:: The AffinityLabel object to add to the affinity group.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all virtual machine labels assigned to this affinity group. The order of the returned labels isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of virtual machine labels to return. If not specified, all the labels are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List all virtual machine labels assigned to this affinity group. The order of the returned labels isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of virtual machine labels to return.
If not specified, all the labels are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def label_service(self, id): """ Access the service that manages the virtual machine label assignment to this affinity group. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupVmLabelService(self._connection, '%s/%s' % (self._path, id))
Access the service that manages the virtual machine label assignment to this affinity group.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityGroupVmsService(Service): """ This service manages a collection of all the virtual machines assigned to an affinity group. """ def __init__(self, connection, path): super(AffinityGroupVmsService, self).__init__(connection, path) self._vm_service = None def add( self, vm, headers=None, query=None, wait=True, **kwargs ): """ Adds a virtual machine to the affinity group. For example, to add the virtual machine `789` to the affinity group `456` of cluster `123`, send a request like this: .... POST /ovirt-engine/api/clusters/123/affinitygroups/456/vms .... With the following body: [source,xml] ---- <vm id="789"/> ---- """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all virtual machines assigned to this affinity group. The order of the returned virtual machines isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of virtual machines to return. If not specified, all the virtual machines are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def vm_service(self, id): """ Access the service that manages the virtual machine assignment to this affinity group. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupVmService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.vm_service(path) return self.vm_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityGroupVmsService:%s' % self._path
This service manages a collection of all the virtual machines assigned to an affinity group.
View Source
def __init__(self, connection, path): super(AffinityGroupVmsService, self).__init__(connection, path) self._vm_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, vm, headers=None, query=None, wait=True, **kwargs ): """ Adds a virtual machine to the affinity group. For example, to add the virtual machine `789` to the affinity group `456` of cluster `123`, send a request like this: .... POST /ovirt-engine/api/clusters/123/affinitygroups/456/vms .... With the following body: [source,xml] ---- <vm id="789"/> ---- """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait)
Adds a virtual machine to the affinity group.
For example, to add the virtual machine 789 to the affinity group 456 of cluster 123, send a request like
this:
....
POST /ovirt-engine/api/clusters/123/affinitygroups/456/vms
....
With the following body:
[source,xml]
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all virtual machines assigned to this affinity group. The order of the returned virtual machines isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of virtual machines to return. If not specified, all the virtual machines are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List all virtual machines assigned to this affinity group. The order of the returned virtual machines isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of virtual machines to return. If not specified, all the virtual machines are
returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def vm_service(self, id): """ Access the service that manages the virtual machine assignment to this affinity group. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupVmService(self._connection, '%s/%s' % (self._path, id))
Access the service that manages the virtual machine assignment to this affinity group.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.vm_service(path) return self.vm_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityGroupsService(Service): """ The affinity groups service manages virtual machine relationships and dependencies. """ def __init__(self, connection, path): super(AffinityGroupsService, self).__init__(connection, path) self._group_service = None def add( self, group, headers=None, query=None, wait=True, **kwargs ): """ Create a new affinity group. Post a request like in the example below to create a new affinity group: [source] ---- POST /ovirt-engine/api/clusters/000-000/affinitygroups ---- And use the following example in its body: [source,xml] ---- <affinity_group> <name>AF_GROUP_001</name> <hosts_rule> <enforcing>true</enforcing> <positive>true</positive> </hosts_rule> <vms_rule> <enabled>false</enabled> </vms_rule> </affinity_group> ---- This method supports the following parameters: `group`:: The affinity group object to create. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('group', group, types.AffinityGroup), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(group, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List existing affinity groups. The order of the affinity groups results isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of affinity groups to return. If not specified all the affinity groups are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def group_service(self, id): """ Access the affinity group service that manages the affinity group specified by an ID. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.group_service(path) return self.group_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityGroupsService:%s' % self._path
The affinity groups service manages virtual machine relationships and dependencies.
View Source
def __init__(self, connection, path): super(AffinityGroupsService, self).__init__(connection, path) self._group_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, group, headers=None, query=None, wait=True, **kwargs ): """ Create a new affinity group. Post a request like in the example below to create a new affinity group: [source] ---- POST /ovirt-engine/api/clusters/000-000/affinitygroups ---- And use the following example in its body: [source,xml] ---- <affinity_group> <name>AF_GROUP_001</name> <hosts_rule> <enforcing>true</enforcing> <positive>true</positive> </hosts_rule> <vms_rule> <enabled>false</enabled> </vms_rule> </affinity_group> ---- This method supports the following parameters: `group`:: The affinity group object to create. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('group', group, types.AffinityGroup), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(group, headers, query, wait)
Create a new affinity group. Post a request like in the example below to create a new affinity group:
[source]
POST /ovirt-engine/api/clusters/000-000/affinitygroups
And use the following example in its body:
[source,xml]
This method supports the following parameters:
group:: The affinity group object to create.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List existing affinity groups. The order of the affinity groups results isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of affinity groups to return. If not specified all the affinity groups are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List existing affinity groups. The order of the affinity groups results isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of affinity groups to return. If not specified all the affinity groups are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def group_service(self, id): """ Access the affinity group service that manages the affinity group specified by an ID. """ Service._check_types([ ('id', id, str), ]) return AffinityGroupService(self._connection, '%s/%s' % (self._path, id))
Access the affinity group service that manages the affinity group specified by an ID.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.group_service(path) return self.group_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityLabelService(Service): """ The details of a single affinity label. """ def __init__(self, connection, path): super(AffinityLabelService, self).__init__(connection, path) self._hosts_service = None self._vms_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the details of a label. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes a label from the system and clears all assignments of the removed label. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, label, headers=None, query=None, wait=True, **kwargs ): """ Updates a label. This call will update all metadata, such as the name or description. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(label, headers, query, wait) def hosts_service(self): """ List all hosts with this label. """ return AffinityLabelHostsService(self._connection, '%s/hosts' % self._path) def vms_service(self): """ List all virtual machines with this label. """ return AffinityLabelVmsService(self._connection, '%s/vms' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'hosts': return self.hosts_service() if path.startswith('hosts/'): return self.hosts_service().service(path[6:]) if path == 'vms': return self.vms_service() if path.startswith('vms/'): return self.vms_service().service(path[4:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityLabelService:%s' % self._path
The details of a single affinity label.
View Source
def __init__(self, connection, path): super(AffinityLabelService, self).__init__(connection, path) self._hosts_service = None self._vms_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the details of a label. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the details of a label.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes a label from the system and clears all assignments of the removed label. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes a label from the system and clears all assignments of the removed label.
View Source
def update( self, label, headers=None, query=None, wait=True, **kwargs ): """ Updates a label. This call will update all metadata, such as the name or description. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(label, headers, query, wait)
Updates a label. This call will update all metadata, such as the name or description.
View Source
def hosts_service(self): """ List all hosts with this label. """ return AffinityLabelHostsService(self._connection, '%s/hosts' % self._path)
List all hosts with this label.
View Source
def vms_service(self): """ List all virtual machines with this label. """ return AffinityLabelVmsService(self._connection, '%s/vms' % self._path)
List all virtual machines with this label.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'hosts': return self.hosts_service() if path.startswith('hosts/'): return self.hosts_service().service(path[6:]) if path == 'vms': return self.vms_service() if path.startswith('vms/'): return self.vms_service().service(path[4:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityLabelHostService(Service): """ This service represents a host that has a specific label when accessed through the affinitylabels/hosts subcollection. """ def __init__(self, connection, path): super(AffinityLabelHostService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves details about a host that has this label assigned. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Remove a label from a host. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityLabelHostService:%s' % self._path
This service represents a host that has a specific label when accessed through the affinitylabels/hosts subcollection.
View Source
def __init__(self, connection, path): super(AffinityLabelHostService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves details about a host that has this label assigned. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves details about a host that has this label assigned.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Remove a label from a host. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove a label from a host.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityLabelHostsService(Service): """ This service represents list of hosts that have a specific label when accessed through the affinitylabels/hosts subcollection. """ def __init__(self, connection, path): super(AffinityLabelHostsService, self).__init__(connection, path) self._host_service = None def add( self, host, headers=None, query=None, wait=True, **kwargs ): """ Add a label to a host. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(host, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List all hosts with the label. The order of the returned hosts isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def host_service(self, id): """ A link to the specific label-host assignment to allow label removal. """ Service._check_types([ ('id', id, str), ]) return AffinityLabelHostService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityLabelHostsService:%s' % self._path
This service represents list of hosts that have a specific label when accessed through the affinitylabels/hosts subcollection.
View Source
def __init__(self, connection, path): super(AffinityLabelHostsService, self).__init__(connection, path) self._host_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, host, headers=None, query=None, wait=True, **kwargs ): """ Add a label to a host. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(host, headers, query, wait)
Add a label to a host.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List all hosts with the label. The order of the returned hosts isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List all hosts with the label. The order of the returned hosts isn't guaranteed.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def host_service(self, id): """ A link to the specific label-host assignment to allow label removal. """ Service._check_types([ ('id', id, str), ]) return AffinityLabelHostService(self._connection, '%s/%s' % (self._path, id))
A link to the specific label-host assignment to allow label removal.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityLabelVmService(Service): """ This service represents a vm that has a specific label when accessed through the affinitylabels/vms subcollection. """ def __init__(self, connection, path): super(AffinityLabelVmService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves details about a vm that has this label assigned. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Remove a label from a vm. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AffinityLabelVmService:%s' % self._path
This service represents a vm that has a specific label when accessed through the affinitylabels/vms subcollection.
View Source
def __init__(self, connection, path): super(AffinityLabelVmService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves details about a vm that has this label assigned. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves details about a vm that has this label assigned.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Remove a label from a vm. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove a label from a vm.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityLabelVmsService(Service): """ This service represents list of vms that have a specific label when accessed through the affinitylabels/vms subcollection. """ def __init__(self, connection, path): super(AffinityLabelVmsService, self).__init__(connection, path) self._vm_service = None def add( self, vm, headers=None, query=None, wait=True, **kwargs ): """ Add a label to a vm. """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List all virtual machines with the label. The order of the returned virtual machines isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def vm_service(self, id): """ A link to the specific label-vm assignment to allow label removal. """ Service._check_types([ ('id', id, str), ]) return AffinityLabelVmService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.vm_service(path) return self.vm_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityLabelVmsService:%s' % self._path
This service represents list of vms that have a specific label when accessed through the affinitylabels/vms subcollection.
View Source
def __init__(self, connection, path): super(AffinityLabelVmsService, self).__init__(connection, path) self._vm_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, vm, headers=None, query=None, wait=True, **kwargs ): """ Add a label to a vm. """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait)
Add a label to a vm.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List all virtual machines with the label. The order of the returned virtual machines isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List all virtual machines with the label. The order of the returned virtual machines isn't guaranteed.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def vm_service(self, id): """ A link to the specific label-vm assignment to allow label removal. """ Service._check_types([ ('id', id, str), ]) return AffinityLabelVmService(self._connection, '%s/%s' % (self._path, id))
A link to the specific label-vm assignment to allow label removal.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.vm_service(path) return self.vm_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AffinityLabelsService(Service): """ Manages the affinity labels available in the system. """ def __init__(self, connection, path): super(AffinityLabelsService, self).__init__(connection, path) self._label_service = None def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Creates a new label. The label is automatically attached to all entities mentioned in the vms or hosts lists. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all labels present in the system. The order of the returned labels isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of labels to return. If not specified all the labels are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def label_service(self, id): """ Link to a single label details. """ Service._check_types([ ('id', id, str), ]) return AffinityLabelService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AffinityLabelsService:%s' % self._path
Manages the affinity labels available in the system.
View Source
def __init__(self, connection, path): super(AffinityLabelsService, self).__init__(connection, path) self._label_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Creates a new label. The label is automatically attached to all entities mentioned in the vms or hosts lists. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait)
Creates a new label. The label is automatically attached to all entities mentioned in the vms or hosts lists.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all labels present in the system. The order of the returned labels isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of labels to return. If not specified all the labels are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists all labels present in the system. The order of the returned labels isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of labels to return. If not specified all the labels are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def label_service(self, id): """ Link to a single label details. """ Service._check_types([ ('id', id, str), ]) return AffinityLabelService(self._connection, '%s/%s' % (self._path, id))
Link to a single label details.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AreaService(Service): """ This annotation is intended to specify what oVirt area is the annotated concept related to. Currently the following areas are in use, and they are closely related to the oVirt teams, but not necessarily the same: - Infrastructure - Network - SLA - Storage - Virtualization A concept may be associated to more than one area, or to no area. The value of this annotation is intended for reporting only, and it doesn't affect at all the generated code or the validity of the model """ def __init__(self, connection, path): super(AreaService, self).__init__(connection, path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AreaService:%s' % self._path
This annotation is intended to specify what oVirt area is the annotated concept related to. Currently the following areas are in use, and they are closely related to the oVirt teams, but not necessarily the same:
- Infrastructure
- Network
- SLA
- Storage
- Virtualization A concept may be associated to more than one area, or to no area. The value of this annotation is intended for reporting only, and it doesn't affect at all the generated code or the validity of the model
View Source
def __init__(self, connection, path): super(AreaService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AssignedAffinityLabelService(Service): """ This service represents one label to entity assignment when accessed using the entities/affinitylabels subcollection. """ def __init__(self, connection, path): super(AssignedAffinityLabelService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves details about the attached label. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes the label from an entity. Does not touch the label itself. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AssignedAffinityLabelService:%s' % self._path
This service represents one label to entity assignment when accessed using the entities/affinitylabels subcollection.
View Source
def __init__(self, connection, path): super(AssignedAffinityLabelService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves details about the attached label. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves details about the attached label.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes the label from an entity. Does not touch the label itself. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the label from an entity. Does not touch the label itself.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AssignedAffinityLabelsService(Service): """ This service is used to list and manipulate affinity labels that are assigned to supported entities when accessed using entities/affinitylabels. """ def __init__(self, connection, path): super(AssignedAffinityLabelsService, self).__init__(connection, path) self._label_service = None def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Attaches a label to an entity. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all labels that are attached to an entity. The order of the returned entities isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def label_service(self, id): """ Link to the specific entity-label assignment to allow removal. """ Service._check_types([ ('id', id, str), ]) return AssignedAffinityLabelService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AssignedAffinityLabelsService:%s' % self._path
This service is used to list and manipulate affinity labels that are assigned to supported entities when accessed using entities/affinitylabels.
View Source
def __init__(self, connection, path): super(AssignedAffinityLabelsService, self).__init__(connection, path) self._label_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Attaches a label to an entity. """ # Check the types of the parameters: Service._check_types([ ('label', label, types.AffinityLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait)
Attaches a label to an entity.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all labels that are attached to an entity. The order of the returned entities isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists all labels that are attached to an entity. The order of the returned entities isn't guaranteed.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def label_service(self, id): """ Link to the specific entity-label assignment to allow removal. """ Service._check_types([ ('id', id, str), ]) return AssignedAffinityLabelService(self._connection, '%s/%s' % (self._path, id))
Link to the specific entity-label assignment to allow removal.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AssignedCpuProfileService(Service): """ """ def __init__(self, connection, path): super(AssignedCpuProfileService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AssignedCpuProfileService:%s' % self._path
View Source
def __init__(self, connection, path): super(AssignedCpuProfileService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AssignedCpuProfilesService(Service): """ """ def __init__(self, connection, path): super(AssignedCpuProfilesService, self).__init__(connection, path) self._profile_service = None def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new cpu profile for the cluster. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.CpuProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the CPU profiles assigned to the cluster. The order of the returned CPU profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return AssignedCpuProfileService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AssignedCpuProfilesService:%s' % self._path
View Source
def __init__(self, connection, path): super(AssignedCpuProfilesService, self).__init__(connection, path) self._profile_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new cpu profile for the cluster. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.CpuProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait)
Add a new cpu profile for the cluster.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the CPU profiles assigned to the cluster. The order of the returned CPU profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List the CPU profiles assigned to the cluster. The order of the returned CPU profiles isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of profiles to return. If not specified all the profiles are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return AssignedCpuProfileService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AssignedDiskProfileService(Service): """ """ def __init__(self, connection, path): super(AssignedDiskProfileService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AssignedDiskProfileService:%s' % self._path
View Source
def __init__(self, connection, path): super(AssignedDiskProfileService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AssignedDiskProfilesService(Service): """ """ def __init__(self, connection, path): super(AssignedDiskProfilesService, self).__init__(connection, path) self._profile_service = None def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new disk profile for the storage domain. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.DiskProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disk profiles assigned to the storage domain. The order of the returned disk profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return AssignedDiskProfileService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AssignedDiskProfilesService:%s' % self._path
View Source
def __init__(self, connection, path): super(AssignedDiskProfilesService, self).__init__(connection, path) self._profile_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new disk profile for the storage domain. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.DiskProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait)
Add a new disk profile for the storage domain.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disk profiles assigned to the storage domain. The order of the returned disk profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of disk profiles assigned to the storage domain. The order of the returned disk profiles isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of profiles to return. If not specified all the profiles are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return AssignedDiskProfileService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AssignedPermissionsService(Service): """ Represents a permission sub-collection, scoped by user, group or some entity type. """ def __init__(self, connection, path): super(AssignedPermissionsService, self).__init__(connection, path) self._permission_service = None def add( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Assign a new permission to a user or group for specific entity. For example, to assign the `UserVmManager` role to the virtual machine with id `123` to the user with id `456` send a request like this: .... POST /ovirt-engine/api/vms/123/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>UserVmManager</name> </role> <user id="456"/> </permission> ---- To assign the `SuperUser` role to the system to the user with id `456` send a request like this: .... POST /ovirt-engine/api/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>SuperUser</name> </role> <user id="456"/> </permission> ---- If you want to assign permission to the group instead of the user please replace the `user` element with the `group` element with proper `id` of the group. For example to assign the `UserRole` role to the cluster with id `123` to the group with id `789` send a request like this: .... POST /ovirt-engine/api/clusters/123/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>UserRole</name> </role> <group id="789"/> </permission> ---- This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_cluster_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the cluster to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_data_center_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the data center to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_group_level( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new group level permission for a given virtual machine. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_host_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the host to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List all the permissions of the specific entity. For example to list all the permissions of the cluster with id `123` send a request like this: .... GET /ovirt-engine/api/clusters/123/permissions .... [source,xml] ---- <permissions> <permission id="456"> <cluster id="123"/> <role id="789"/> <user id="451"/> </permission> <permission id="654"> <cluster id="123"/> <role id="789"/> <group id="127"/> </permission> </permissions> ---- The order of the returned permissions isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def add_storage_domain_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the storage domain to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_template_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the template to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_user_level( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new user level permission for a given virtual machine. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_vm_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the vm to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_vm_pool_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the vm pool to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def permission_service(self, id): """ Sub-resource locator method, returns individual permission resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return PermissionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.permission_service(path) return self.permission_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AssignedPermissionsService:%s' % self._path
Represents a permission sub-collection, scoped by user, group or some entity type.
View Source
def __init__(self, connection, path): super(AssignedPermissionsService, self).__init__(connection, path) self._permission_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Assign a new permission to a user or group for specific entity. For example, to assign the `UserVmManager` role to the virtual machine with id `123` to the user with id `456` send a request like this: .... POST /ovirt-engine/api/vms/123/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>UserVmManager</name> </role> <user id="456"/> </permission> ---- To assign the `SuperUser` role to the system to the user with id `456` send a request like this: .... POST /ovirt-engine/api/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>SuperUser</name> </role> <user id="456"/> </permission> ---- If you want to assign permission to the group instead of the user please replace the `user` element with the `group` element with proper `id` of the group. For example to assign the `UserRole` role to the cluster with id `123` to the group with id `789` send a request like this: .... POST /ovirt-engine/api/clusters/123/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>UserRole</name> </role> <group id="789"/> </permission> ---- This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Assign a new permission to a user or group for specific entity.
For example, to assign the UserVmManager role to the virtual machine with id 123 to the user with id 456
send a request like this:
....
POST /ovirt-engine/api/vms/123/permissions
....
With a request body like this:
[source,xml]
To assign the SuperUser role to the system to the user with id 456 send a request like this:
....
POST /ovirt-engine/api/permissions
....
With a request body like this:
[source,xml]
If you want to assign permission to the group instead of the user please replace the user element with the
group element with proper id of the group. For example to assign the UserRole role to the cluster with
id 123 to the group with id 789 send a request like this:
....
POST /ovirt-engine/api/clusters/123/permissions
....
With a request body like this:
[source,xml]
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_cluster_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the cluster to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new permission on the cluster to the group in the system.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_data_center_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the data center to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new permission on the data center to the group in the system.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_group_level( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new group level permission for a given virtual machine. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new group level permission for a given virtual machine.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_host_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the host to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new permission on the host to the group in the system.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List all the permissions of the specific entity. For example to list all the permissions of the cluster with id `123` send a request like this: .... GET /ovirt-engine/api/clusters/123/permissions .... [source,xml] ---- <permissions> <permission id="456"> <cluster id="123"/> <role id="789"/> <user id="451"/> </permission> <permission id="654"> <cluster id="123"/> <role id="789"/> <group id="127"/> </permission> </permissions> ---- The order of the returned permissions isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List all the permissions of the specific entity.
For example to list all the permissions of the cluster with id 123 send a request like this:
....
GET /ovirt-engine/api/clusters/123/permissions
....
[source,xml]
The order of the returned permissions isn't guaranteed.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
add_storage_domain_permission(self, permission, headers=None, query=None, wait=True, **kwargs):
View Source
def add_storage_domain_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the storage domain to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new permission on the storage domain to the group in the system.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_template_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the template to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new permission on the template to the group in the system.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_user_level( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new user level permission for a given virtual machine. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new user level permission for a given virtual machine.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_vm_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the vm to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new permission on the vm to the group in the system.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_vm_pool_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the vm pool to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new permission on the vm pool to the group in the system.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def permission_service(self, id): """ Sub-resource locator method, returns individual permission resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return PermissionService(self._connection, '%s/%s' % (self._path, id))
Sub-resource locator method, returns individual permission resource on which the remainder of the URI is dispatched.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.permission_service(path) return self.permission_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AssignedRolesService(Service): """ Represents a roles sub-collection, for example scoped by user. """ def __init__(self, connection, path): super(AssignedRolesService, self).__init__(connection, path) self._role_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the roles assigned to the permission. The order of the returned roles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of roles to return. If not specified all the roles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def role_service(self, id): """ Sub-resource locator method, returns individual role resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return RoleService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.role_service(path) return self.role_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AssignedRolesService:%s' % self._path
Represents a roles sub-collection, for example scoped by user.
View Source
def __init__(self, connection, path): super(AssignedRolesService, self).__init__(connection, path) self._role_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the roles assigned to the permission. The order of the returned roles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of roles to return. If not specified all the roles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the roles assigned to the permission. The order of the returned roles isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of roles to return. If not specified all the roles are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def role_service(self, id): """ Sub-resource locator method, returns individual role resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return RoleService(self._connection, '%s/%s' % (self._path, id))
Sub-resource locator method, returns individual role resource on which the remainder of the URI is dispatched.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.role_service(path) return self.role_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AssignedTagService(Service): """ A service to manage assignment of specific tag to specific entities in system. """ def __init__(self, connection, path): super(AssignedTagService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the information about the assigned tag. For example to retrieve the information about the tag with the id `456` which is assigned to virtual machine with id `123` send a request like this: .... GET /ovirt-engine/api/vms/123/tags/456 .... [source,xml] ---- <tag href="/ovirt-engine/api/tags/456" id="456"> <name>root</name> <description>root</description> <vm href="/ovirt-engine/api/vms/123" id="123"/> </tag> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Unassign tag from specific entity in the system. For example to unassign the tag with id `456` from virtual machine with id `123` send a request like this: .... DELETE /ovirt-engine/api/vms/123/tags/456 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AssignedTagService:%s' % self._path
A service to manage assignment of specific tag to specific entities in system.
View Source
def __init__(self, connection, path): super(AssignedTagService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the information about the assigned tag. For example to retrieve the information about the tag with the id `456` which is assigned to virtual machine with id `123` send a request like this: .... GET /ovirt-engine/api/vms/123/tags/456 .... [source,xml] ---- <tag href="/ovirt-engine/api/tags/456" id="456"> <name>root</name> <description>root</description> <vm href="/ovirt-engine/api/vms/123" id="123"/> </tag> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets the information about the assigned tag.
For example to retrieve the information about the tag with the id 456 which is assigned to virtual machine
with id 123 send a request like this:
....
GET /ovirt-engine/api/vms/123/tags/456
....
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Unassign tag from specific entity in the system. For example to unassign the tag with id `456` from virtual machine with id `123` send a request like this: .... DELETE /ovirt-engine/api/vms/123/tags/456 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Unassign tag from specific entity in the system.
For example to unassign the tag with id 456 from virtual machine with id 123 send a request like this:
....
DELETE /ovirt-engine/api/vms/123/tags/456
....
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AssignedTagsService(Service): """ A service to manage collection of assignment of tags to specific entities in system. """ def __init__(self, connection, path): super(AssignedTagsService, self).__init__(connection, path) self._tag_service = None def add( self, tag, headers=None, query=None, wait=True, **kwargs ): """ Assign tag to specific entity in the system. For example to assign tag `mytag` to virtual machine with the id `123` send a request like this: .... POST /ovirt-engine/api/vms/123/tags .... With a request body like this: [source,xml] ---- <tag> <name>mytag</name> </tag> ---- This method supports the following parameters: `tag`:: The assigned tag. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('tag', tag, types.Tag), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(tag, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all tags assigned to the specific entity. For example to list all the tags of the virtual machine with id `123` send a request like this: .... GET /ovirt-engine/api/vms/123/tags .... [source,xml] ---- <tags> <tag href="/ovirt-engine/api/tags/222" id="222"> <name>mytag</name> <description>mytag</description> <vm href="/ovirt-engine/api/vms/123" id="123"/> </tag> </tags> ---- The order of the returned tags isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of tags to return. If not specified all the tags are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def tag_service(self, id): """ Reference to the service that manages assignment of specific tag. """ Service._check_types([ ('id', id, str), ]) return AssignedTagService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.tag_service(path) return self.tag_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AssignedTagsService:%s' % self._path
A service to manage collection of assignment of tags to specific entities in system.
View Source
def __init__(self, connection, path): super(AssignedTagsService, self).__init__(connection, path) self._tag_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, tag, headers=None, query=None, wait=True, **kwargs ): """ Assign tag to specific entity in the system. For example to assign tag `mytag` to virtual machine with the id `123` send a request like this: .... POST /ovirt-engine/api/vms/123/tags .... With a request body like this: [source,xml] ---- <tag> <name>mytag</name> </tag> ---- This method supports the following parameters: `tag`:: The assigned tag. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('tag', tag, types.Tag), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(tag, headers, query, wait)
Assign tag to specific entity in the system.
For example to assign tag mytag to virtual machine with the id 123 send a request like this:
....
POST /ovirt-engine/api/vms/123/tags
....
With a request body like this:
[source,xml]
This method supports the following parameters:
tag:: The assigned tag.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all tags assigned to the specific entity. For example to list all the tags of the virtual machine with id `123` send a request like this: .... GET /ovirt-engine/api/vms/123/tags .... [source,xml] ---- <tags> <tag href="/ovirt-engine/api/tags/222" id="222"> <name>mytag</name> <description>mytag</description> <vm href="/ovirt-engine/api/vms/123" id="123"/> </tag> </tags> ---- The order of the returned tags isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of tags to return. If not specified all the tags are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List all tags assigned to the specific entity.
For example to list all the tags of the virtual machine with id 123 send a request like this:
....
GET /ovirt-engine/api/vms/123/tags
....
[source,xml]
The order of the returned tags isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of tags to return. If not specified all the tags are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def tag_service(self, id): """ Reference to the service that manages assignment of specific tag. """ Service._check_types([ ('id', id, str), ]) return AssignedTagService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages assignment of specific tag.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.tag_service(path) return self.tag_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AssignedVnicProfileService(Service): """ """ def __init__(self, connection, path): super(AssignedVnicProfileService, self).__init__(connection, path) self._permissions_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AssignedVnicProfileService:%s' % self._path
View Source
def __init__(self, connection, path): super(AssignedVnicProfileService, self).__init__(connection, path) self._permissions_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AssignedVnicProfilesService(Service): """ """ def __init__(self, connection, path): super(AssignedVnicProfilesService, self).__init__(connection, path) self._profile_service = None def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new virtual network interface card profile for the network. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.VnicProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of VNIC profiles assifned to the network. The order of the returned VNIC profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return AssignedVnicProfileService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AssignedVnicProfilesService:%s' % self._path
View Source
def __init__(self, connection, path): super(AssignedVnicProfilesService, self).__init__(connection, path) self._profile_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new virtual network interface card profile for the network. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.VnicProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait)
Add a new virtual network interface card profile for the network.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of VNIC profiles assifned to the network. The order of the returned VNIC profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of VNIC profiles assifned to the network. The order of the returned VNIC profiles isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of profiles to return. If not specified all the profiles are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return AssignedVnicProfileService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AttachedStorageDomainService(Service): """ """ def __init__(self, connection, path): super(AttachedStorageDomainService, self).__init__(connection, path) self._disks_service = None def activate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation activates an attached storage domain. Once the storage domain is activated it is ready for use with the data center. [source] ---- POST /ovirt-engine/api/datacenters/123/storagedomains/456/activate ---- The activate action does not take any action specific parameters, so the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait) def deactivate( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ This operation deactivates an attached storage domain. Once the storage domain is deactivated it will not be used with the data center. For example, to deactivate storage domain `456`, send the following request: [source] ---- POST /ovirt-engine/api/datacenters/123/storagedomains/456/deactivate ---- With a request body like this: [source,xml] ---- <action/> ---- If the `force` parameter is `true` then the operation will succeed, even if the OVF update which takes place before the deactivation of the storage domain failed. If the `force` parameter is `false` and the OVF update failed, the deactivation of the storage domain will also fail. This method supports the following parameters: `async_`:: Indicates if the deactivation should be performed asynchronously. `force`:: Indicates if the operation should succeed and the storage domain should be moved to a deactivated state, even if the OVF update for the storage domain failed. For example, to deactivate storage domain `456` using force flag, send the following request: [source] ---- POST /ovirt-engine/api/datacenters/123/storagedomains/456/deactivate ---- With a request body like this: [source,xml] ---- <action> <force>true</force> <action> ---- This parameter is optional, and the default value is `false`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'deactivate', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def disks_service(self): """ """ return AttachedStorageDomainDisksService(self._connection, '%s/disks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AttachedStorageDomainService:%s' % self._path
View Source
def __init__(self, connection, path): super(AttachedStorageDomainService, self).__init__(connection, path) self._disks_service = None
Creates a new service that will use the given connection and path.
View Source
def activate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation activates an attached storage domain. Once the storage domain is activated it is ready for use with the data center. [source] ---- POST /ovirt-engine/api/datacenters/123/storagedomains/456/activate ---- The activate action does not take any action specific parameters, so the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait)
This operation activates an attached storage domain. Once the storage domain is activated it is ready for use with the data center.
[source]
POST /ovirt-engine/api/datacenters/123/storagedomains/456/activate
The activate action does not take any action specific parameters,
so the request body should contain an empty action:
[source,xml]
This method supports the following parameters:
async_:: Indicates if the activation should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def deactivate( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ This operation deactivates an attached storage domain. Once the storage domain is deactivated it will not be used with the data center. For example, to deactivate storage domain `456`, send the following request: [source] ---- POST /ovirt-engine/api/datacenters/123/storagedomains/456/deactivate ---- With a request body like this: [source,xml] ---- <action/> ---- If the `force` parameter is `true` then the operation will succeed, even if the OVF update which takes place before the deactivation of the storage domain failed. If the `force` parameter is `false` and the OVF update failed, the deactivation of the storage domain will also fail. This method supports the following parameters: `async_`:: Indicates if the deactivation should be performed asynchronously. `force`:: Indicates if the operation should succeed and the storage domain should be moved to a deactivated state, even if the OVF update for the storage domain failed. For example, to deactivate storage domain `456` using force flag, send the following request: [source] ---- POST /ovirt-engine/api/datacenters/123/storagedomains/456/deactivate ---- With a request body like this: [source,xml] ---- <action> <force>true</force> <action> ---- This parameter is optional, and the default value is `false`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'deactivate', None, headers, query, wait)
This operation deactivates an attached storage domain.
Once the storage domain is deactivated it will not be used with the data center.
For example, to deactivate storage domain 456, send the following request:
[source]
POST /ovirt-engine/api/datacenters/123/storagedomains/456/deactivate
With a request body like this:
[source,xml]
If the force parameter is true then the operation will succeed, even if the OVF update which takes place
before the deactivation of the storage domain failed. If the force parameter is false and the OVF update failed,
the deactivation of the storage domain will also fail.
This method supports the following parameters:
async_:: Indicates if the deactivation should be performed asynchronously.
force:: Indicates if the operation should succeed and the storage domain should be moved to a deactivated state, even if
the OVF update for the storage domain failed.
For example, to deactivate storage domain 456 using force flag, send the following request:
[source]
POST /ovirt-engine/api/datacenters/123/storagedomains/456/deactivate
With a request body like this:
[source,xml]
This parameter is optional, and the default value is false.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disks_service(self): """ """ return AttachedStorageDomainDisksService(self._connection, '%s/disks' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AttachedStorageDomainDisksService(Service): """ Manages the collection of disks available inside an storage domain that is attached to a data center. """ def __init__(self, connection, path): super(AttachedStorageDomainDisksService, self).__init__(connection, path) self._disk_service = None def add( self, disk, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Adds or registers a disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To add a new disk use the <<services/disks/methods/add, add>> operation of the service that manages the disks of the system. To register an unregistered disk use the <<services/attached_storage_domain_disk/methods/register, register>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: The disk to add or register. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieve the list of disks that are available in the storage domain. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ Reference to the service that manages a specific disk. """ Service._check_types([ ('id', id, str), ]) return AttachedStorageDomainDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AttachedStorageDomainDisksService:%s' % self._path
Manages the collection of disks available inside an storage domain that is attached to a data center.
View Source
def __init__(self, connection, path): super(AttachedStorageDomainDisksService, self).__init__(connection, path) self._disk_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, disk, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Adds or registers a disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To add a new disk use the <<services/disks/methods/add, add>> operation of the service that manages the disks of the system. To register an unregistered disk use the <<services/attached_storage_domain_disk/methods/register, register>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: The disk to add or register. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait)
Adds or registers a disk.
IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. To add a new disk use the <
This method supports the following parameters:
disk:: The disk to add or register.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieve the list of disks that are available in the storage domain. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieve the list of disks that are available in the storage domain.
This method supports the following parameters:
max:: Sets the maximum number of disks to return. If not specified all the disks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disk_service(self, id): """ Reference to the service that manages a specific disk. """ Service._check_types([ ('id', id, str), ]) return AttachedStorageDomainDiskService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages a specific disk.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AttachedStorageDomainsService(Service): """ Manages the storage domains attached to a data center. """ def __init__(self, connection, path): super(AttachedStorageDomainsService, self).__init__(connection, path) self._storage_domain_service = None def add( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Attaches an existing storage domain to the data center. This method supports the following parameters: `storage_domain`:: The storage domain to attach to the data center. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of storage domains attached to the data center. The order of the returned storage domains isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of storage domains to return. If not specified all the storage domains are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def storage_domain_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return AttachedStorageDomainService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_domain_service(path) return self.storage_domain_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'AttachedStorageDomainsService:%s' % self._path
Manages the storage domains attached to a data center.
View Source
def __init__(self, connection, path): super(AttachedStorageDomainsService, self).__init__(connection, path) self._storage_domain_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Attaches an existing storage domain to the data center. This method supports the following parameters: `storage_domain`:: The storage domain to attach to the data center. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait)
Attaches an existing storage domain to the data center.
This method supports the following parameters:
storage_domain:: The storage domain to attach to the data center.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of storage domains attached to the data center. The order of the returned storage domains isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of storage domains to return. If not specified all the storage domains are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of storage domains attached to the data center. The order of the returned storage domains isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of storage domains to return. If not specified all the storage domains are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def storage_domain_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return AttachedStorageDomainService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_domain_service(path) return self.storage_domain_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class BalanceService(Service): """ """ def __init__(self, connection, path): super(BalanceService, self).__init__(connection, path) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'BalanceService:%s' % self._path
View Source
def __init__(self, connection, path): super(BalanceService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class BalancesService(Service): """ """ def __init__(self, connection, path): super(BalancesService, self).__init__(connection, path) self._balance_service = None def add( self, balance, headers=None, query=None, wait=True, **kwargs ): """ Add a balance module to a specified user defined scheduling policy. """ # Check the types of the parameters: Service._check_types([ ('balance', balance, types.Balance), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(balance, headers, query, wait) def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of balance modules used by the scheduling policy. The order of the returned balance modules isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of balances to return. If not specified all the balances are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def balance_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return BalanceService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.balance_service(path) return self.balance_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'BalancesService:%s' % self._path
View Source
def __init__(self, connection, path): super(BalancesService, self).__init__(connection, path) self._balance_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, balance, headers=None, query=None, wait=True, **kwargs ): """ Add a balance module to a specified user defined scheduling policy. """ # Check the types of the parameters: Service._check_types([ ('balance', balance, types.Balance), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(balance, headers, query, wait)
Add a balance module to a specified user defined scheduling policy.
#
def
list(
self,
filter=None,
follow=None,
max=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of balance modules used by the scheduling policy. The order of the returned balance modules isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of balances to return. If not specified all the balances are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of balance modules used by the scheduling policy. The order of the returned balance modules isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of balances to return. If not specified all the balances are returned.
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def balance_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return BalanceService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.balance_service(path) return self.balance_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class BookmarkService(Service): """ A service to manage a bookmark. """ def __init__(self, connection, path): super(BookmarkService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get a bookmark. An example for getting a bookmark: [source] ---- GET /ovirt-engine/api/bookmarks/123 ---- [source,xml] ---- <bookmark href="/ovirt-engine/api/bookmarks/123" id="123"> <name>example_vm</name> <value>vm: name=example*</value> </bookmark> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove a bookmark. An example for removing a bookmark: [source] ---- DELETE /ovirt-engine/api/bookmarks/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, bookmark, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update a bookmark. An example for updating a bookmark: [source] ---- PUT /ovirt-engine/api/bookmarks/123 ---- With the request body: [source,xml] ---- <bookmark> <name>new_example_vm</name> <value>vm: name=new_example*</value> </bookmark> ---- This method supports the following parameters: `bookmark`:: The updated bookmark. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bookmark', bookmark, types.Bookmark), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(bookmark, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'BookmarkService:%s' % self._path
A service to manage a bookmark.
View Source
def __init__(self, connection, path): super(BookmarkService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get a bookmark. An example for getting a bookmark: [source] ---- GET /ovirt-engine/api/bookmarks/123 ---- [source,xml] ---- <bookmark href="/ovirt-engine/api/bookmarks/123" id="123"> <name>example_vm</name> <value>vm: name=example*</value> </bookmark> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get a bookmark. An example for getting a bookmark:
[source]
GET /ovirt-engine/api/bookmarks/123
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove a bookmark. An example for removing a bookmark: [source] ---- DELETE /ovirt-engine/api/bookmarks/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove a bookmark. An example for removing a bookmark:
[source]
DELETE /ovirt-engine/api/bookmarks/123
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, bookmark, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update a bookmark. An example for updating a bookmark: [source] ---- PUT /ovirt-engine/api/bookmarks/123 ---- With the request body: [source,xml] ---- <bookmark> <name>new_example_vm</name> <value>vm: name=new_example*</value> </bookmark> ---- This method supports the following parameters: `bookmark`:: The updated bookmark. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bookmark', bookmark, types.Bookmark), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(bookmark, headers, query, wait)
Update a bookmark. An example for updating a bookmark:
[source]
PUT /ovirt-engine/api/bookmarks/123
With the request body:
[source,xml]
This method supports the following parameters:
bookmark:: The updated bookmark.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class BookmarksService(Service): """ A service to manage bookmarks. """ def __init__(self, connection, path): super(BookmarksService, self).__init__(connection, path) self._bookmark_service = None def add( self, bookmark, headers=None, query=None, wait=True, **kwargs ): """ Adding a new bookmark. Example of adding a bookmark: [source] ---- POST /ovirt-engine/api/bookmarks ---- [source,xml] ---- <bookmark> <name>new_example_vm</name> <value>vm: name=new_example*</value> </bookmark> ---- This method supports the following parameters: `bookmark`:: The added bookmark. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bookmark', bookmark, types.Bookmark), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(bookmark, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Listing all the available bookmarks. Example of listing bookmarks: [source] ---- GET /ovirt-engine/api/bookmarks ---- [source,xml] ---- <bookmarks> <bookmark href="/ovirt-engine/api/bookmarks/123" id="123"> <name>database</name> <value>vm: name=database*</value> </bookmark> <bookmark href="/ovirt-engine/api/bookmarks/456" id="456"> <name>example</name> <value>vm: name=example*</value> </bookmark> </bookmarks> ---- The order of the returned bookmarks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of bookmarks to return. If not specified all the bookmarks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def bookmark_service(self, id): """ A reference to the service managing a specific bookmark. """ Service._check_types([ ('id', id, str), ]) return BookmarkService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.bookmark_service(path) return self.bookmark_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'BookmarksService:%s' % self._path
A service to manage bookmarks.
View Source
def __init__(self, connection, path): super(BookmarksService, self).__init__(connection, path) self._bookmark_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, bookmark, headers=None, query=None, wait=True, **kwargs ): """ Adding a new bookmark. Example of adding a bookmark: [source] ---- POST /ovirt-engine/api/bookmarks ---- [source,xml] ---- <bookmark> <name>new_example_vm</name> <value>vm: name=new_example*</value> </bookmark> ---- This method supports the following parameters: `bookmark`:: The added bookmark. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bookmark', bookmark, types.Bookmark), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(bookmark, headers, query, wait)
Adding a new bookmark. Example of adding a bookmark:
[source]
POST /ovirt-engine/api/bookmarks
[source,xml]
This method supports the following parameters:
bookmark:: The added bookmark.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Listing all the available bookmarks. Example of listing bookmarks: [source] ---- GET /ovirt-engine/api/bookmarks ---- [source,xml] ---- <bookmarks> <bookmark href="/ovirt-engine/api/bookmarks/123" id="123"> <name>database</name> <value>vm: name=database*</value> </bookmark> <bookmark href="/ovirt-engine/api/bookmarks/456" id="456"> <name>example</name> <value>vm: name=example*</value> </bookmark> </bookmarks> ---- The order of the returned bookmarks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of bookmarks to return. If not specified all the bookmarks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Listing all the available bookmarks. Example of listing bookmarks:
[source]
GET /ovirt-engine/api/bookmarks
[source,xml]
The order of the returned bookmarks isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of bookmarks to return. If not specified all the bookmarks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def bookmark_service(self, id): """ A reference to the service managing a specific bookmark. """ Service._check_types([ ('id', id, str), ]) return BookmarkService(self._connection, '%s/%s' % (self._path, id))
A reference to the service managing a specific bookmark.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.bookmark_service(path) return self.bookmark_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ClusterService(Service): """ A service to manage a specific cluster. """ def __init__(self, connection, path): super(ClusterService, self).__init__(connection, path) self._affinity_groups_service = None self._cpu_profiles_service = None self._enabled_features_service = None self._external_network_providers_service = None self._gluster_hooks_service = None self._gluster_volumes_service = None self._network_filters_service = None self._networks_service = None self._permissions_service = None def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets information about the cluster. An example of getting a cluster: [source] ---- GET /ovirt-engine/api/clusters/123 ---- [source,xml] ---- <cluster href="/ovirt-engine/api/clusters/123" id="123"> <actions> <link href="/ovirt-engine/api/clusters/123/resetemulatedmachine" rel="resetemulatedmachine"/> </actions> <name>Default</name> <description>The default server cluster</description> <link href="/ovirt-engine/api/clusters/123/networks" rel="networks"/> <link href="/ovirt-engine/api/clusters/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/clusters/123/glustervolumes" rel="glustervolumes"/> <link href="/ovirt-engine/api/clusters/123/glusterhooks" rel="glusterhooks"/> <link href="/ovirt-engine/api/clusters/123/affinitygroups" rel="affinitygroups"/> <link href="/ovirt-engine/api/clusters/123/cpuprofiles" rel="cpuprofiles"/> <ballooning_enabled>false</ballooning_enabled> <cpu> <architecture>x86_64</architecture> <type>Intel Nehalem Family</type> </cpu> <error_handling> <on_error>migrate</on_error> </error_handling> <fencing_policy> <enabled>true</enabled> <skip_if_connectivity_broken> <enabled>false</enabled> <threshold>50</threshold> </skip_if_connectivity_broken> <skip_if_sd_active> <enabled>false</enabled> </skip_if_sd_active> </fencing_policy> <gluster_service>false</gluster_service> <ha_reservation>false</ha_reservation> <ksm> <enabled>true</enabled> <merge_across_nodes>true</merge_across_nodes> </ksm> <memory_policy> <over_commit> <percent>100</percent> </over_commit> <transparent_hugepages> <enabled>true</enabled> </transparent_hugepages> </memory_policy> <migration> <auto_converge>inherit</auto_converge> <bandwidth> <assignment_method>auto</assignment_method> </bandwidth> <compressed>inherit</compressed> </migration> <required_rng_sources> <required_rng_source>random</required_rng_source> </required_rng_sources> <scheduling_policy href="/ovirt-engine/api/schedulingpolicies/456" id="456"/> <threads_as_cores>false</threads_as_cores> <trusted_service>false</trusted_service> <tunnel_migration>false</tunnel_migration> <version> <major>4</major> <minor>0</minor> </version> <virt_service>true</virt_service> <data_center href="/ovirt-engine/api/datacenters/111" id="111"/> </cluster> ---- This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def refresh_gluster_heal_status( self, headers=None, query=None, wait=True, **kwargs ): """ Refresh the Gluster heal info for all volumes in cluster. For example, Cluster `123`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/123/refreshglusterhealstatus ---- """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'refreshglusterhealstatus', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the cluster from the system. [source] ---- DELETE /ovirt-engine/api/clusters/00000000-0000-0000-0000-000000000000 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def reset_emulated_machine( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the reset should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'resetemulatedmachine', None, headers, query, wait) def sync_all_networks( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Synchronizes all networks on the cluster. [source] ---- POST /ovirt-engine/api/clusters/123/syncallnetworks ---- With a request body like this: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'syncallnetworks', None, headers, query, wait) def update( self, cluster, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates information about the cluster. Only the specified fields are updated; others remain unchanged. For example, to update the cluster's CPU: [source] ---- PUT /ovirt-engine/api/clusters/123 ---- With a request body like this: [source,xml] ---- <cluster> <cpu> <type>Intel Haswell-noTSX Family</type> </cpu> </cluster> ---- """ # Check the types of the parameters: Service._check_types([ ('cluster', cluster, types.Cluster), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(cluster, headers, query, wait) def upgrade( self, async_=None, upgrade_action=None, headers=None, query=None, wait=True, **kwargs ): """ Start or finish upgrade process for the cluster based on the action value. This action marks the cluster for upgrade or clears the upgrade running flag on the cluster based on the action value which takes values of start or stop. [source] ---- POST /ovirt-engine/api/clusters/123/upgrade ---- With a request body like this to mark the cluster for upgrade: [source,xml] ---- <action> <upgrade_action> start </upgrade_action> </action> ---- This method supports the following parameters: `upgrade_action`:: The action to be performed. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('upgrade_action', upgrade_action, types.ClusterUpgradeAction), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, upgrade_action=upgrade_action, ) # Send the request and wait for the response: return self._internal_action(action, 'upgrade', None, headers, query, wait) def affinity_groups_service(self): """ A reference to the service that manages affinity groups. """ return AffinityGroupsService(self._connection, '%s/affinitygroups' % self._path) def cpu_profiles_service(self): """ A reference to the service that manages assigned CPU profiles for the cluster. """ return AssignedCpuProfilesService(self._connection, '%s/cpuprofiles' % self._path) def enabled_features_service(self): """ A reference to the service that manages the collection of enabled features for the cluster. """ return ClusterEnabledFeaturesService(self._connection, '%s/enabledfeatures' % self._path) def external_network_providers_service(self): """ A reference to the service that manages the collection of external network providers. """ return ClusterExternalProvidersService(self._connection, '%s/externalnetworkproviders' % self._path) def gluster_hooks_service(self): """ A reference to the service that manages the Gluster hooks for the cluster. """ return GlusterHooksService(self._connection, '%s/glusterhooks' % self._path) def gluster_volumes_service(self): """ A reference to the service that manages Gluster volumes for the cluster. """ return GlusterVolumesService(self._connection, '%s/glustervolumes' % self._path) def network_filters_service(self): """ A sub-collection with all the supported network filters for the cluster. """ return NetworkFiltersService(self._connection, '%s/networkfilters' % self._path) def networks_service(self): """ A reference to the service that manages assigned networks for the cluster. """ return ClusterNetworksService(self._connection, '%s/networks' % self._path) def permissions_service(self): """ A reference to permissions. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'affinitygroups': return self.affinity_groups_service() if path.startswith('affinitygroups/'): return self.affinity_groups_service().service(path[15:]) if path == 'cpuprofiles': return self.cpu_profiles_service() if path.startswith('cpuprofiles/'): return self.cpu_profiles_service().service(path[12:]) if path == 'enabledfeatures': return self.enabled_features_service() if path.startswith('enabledfeatures/'): return self.enabled_features_service().service(path[16:]) if path == 'externalnetworkproviders': return self.external_network_providers_service() if path.startswith('externalnetworkproviders/'): return self.external_network_providers_service().service(path[25:]) if path == 'glusterhooks': return self.gluster_hooks_service() if path.startswith('glusterhooks/'): return self.gluster_hooks_service().service(path[13:]) if path == 'glustervolumes': return self.gluster_volumes_service() if path.startswith('glustervolumes/'): return self.gluster_volumes_service().service(path[15:]) if path == 'networkfilters': return self.network_filters_service() if path.startswith('networkfilters/'): return self.network_filters_service().service(path[15:]) if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ClusterService:%s' % self._path
A service to manage a specific cluster.
View Source
def __init__(self, connection, path): super(ClusterService, self).__init__(connection, path) self._affinity_groups_service = None self._cpu_profiles_service = None self._enabled_features_service = None self._external_network_providers_service = None self._gluster_hooks_service = None self._gluster_volumes_service = None self._network_filters_service = None self._networks_service = None self._permissions_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets information about the cluster. An example of getting a cluster: [source] ---- GET /ovirt-engine/api/clusters/123 ---- [source,xml] ---- <cluster href="/ovirt-engine/api/clusters/123" id="123"> <actions> <link href="/ovirt-engine/api/clusters/123/resetemulatedmachine" rel="resetemulatedmachine"/> </actions> <name>Default</name> <description>The default server cluster</description> <link href="/ovirt-engine/api/clusters/123/networks" rel="networks"/> <link href="/ovirt-engine/api/clusters/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/clusters/123/glustervolumes" rel="glustervolumes"/> <link href="/ovirt-engine/api/clusters/123/glusterhooks" rel="glusterhooks"/> <link href="/ovirt-engine/api/clusters/123/affinitygroups" rel="affinitygroups"/> <link href="/ovirt-engine/api/clusters/123/cpuprofiles" rel="cpuprofiles"/> <ballooning_enabled>false</ballooning_enabled> <cpu> <architecture>x86_64</architecture> <type>Intel Nehalem Family</type> </cpu> <error_handling> <on_error>migrate</on_error> </error_handling> <fencing_policy> <enabled>true</enabled> <skip_if_connectivity_broken> <enabled>false</enabled> <threshold>50</threshold> </skip_if_connectivity_broken> <skip_if_sd_active> <enabled>false</enabled> </skip_if_sd_active> </fencing_policy> <gluster_service>false</gluster_service> <ha_reservation>false</ha_reservation> <ksm> <enabled>true</enabled> <merge_across_nodes>true</merge_across_nodes> </ksm> <memory_policy> <over_commit> <percent>100</percent> </over_commit> <transparent_hugepages> <enabled>true</enabled> </transparent_hugepages> </memory_policy> <migration> <auto_converge>inherit</auto_converge> <bandwidth> <assignment_method>auto</assignment_method> </bandwidth> <compressed>inherit</compressed> </migration> <required_rng_sources> <required_rng_source>random</required_rng_source> </required_rng_sources> <scheduling_policy href="/ovirt-engine/api/schedulingpolicies/456" id="456"/> <threads_as_cores>false</threads_as_cores> <trusted_service>false</trusted_service> <tunnel_migration>false</tunnel_migration> <version> <major>4</major> <minor>0</minor> </version> <virt_service>true</virt_service> <data_center href="/ovirt-engine/api/datacenters/111" id="111"/> </cluster> ---- This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets information about the cluster. An example of getting a cluster:
[source]
GET /ovirt-engine/api/clusters/123
[source,xml]
This method supports the following parameters:
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def refresh_gluster_heal_status( self, headers=None, query=None, wait=True, **kwargs ): """ Refresh the Gluster heal info for all volumes in cluster. For example, Cluster `123`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/123/refreshglusterhealstatus ---- """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'refreshglusterhealstatus', None, headers, query, wait)
Refresh the Gluster heal info for all volumes in cluster.
For example, Cluster 123, send a request like
this:
[source]
POST /ovirt-engine/api/clusters/123/refreshglusterhealstatus
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the cluster from the system. [source] ---- DELETE /ovirt-engine/api/clusters/00000000-0000-0000-0000-000000000000 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the cluster from the system.
[source]
DELETE /ovirt-engine/api/clusters/00000000-0000-0000-0000-000000000000
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def reset_emulated_machine( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the reset should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'resetemulatedmachine', None, headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the reset should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def sync_all_networks( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Synchronizes all networks on the cluster. [source] ---- POST /ovirt-engine/api/clusters/123/syncallnetworks ---- With a request body like this: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'syncallnetworks', None, headers, query, wait)
Synchronizes all networks on the cluster.
[source]
POST /ovirt-engine/api/clusters/123/syncallnetworks
With a request body like this:
[source,xml]
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, cluster, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates information about the cluster. Only the specified fields are updated; others remain unchanged. For example, to update the cluster's CPU: [source] ---- PUT /ovirt-engine/api/clusters/123 ---- With a request body like this: [source,xml] ---- <cluster> <cpu> <type>Intel Haswell-noTSX Family</type> </cpu> </cluster> ---- """ # Check the types of the parameters: Service._check_types([ ('cluster', cluster, types.Cluster), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(cluster, headers, query, wait)
Updates information about the cluster. Only the specified fields are updated; others remain unchanged. For example, to update the cluster's CPU:
[source]
PUT /ovirt-engine/api/clusters/123
With a request body like this:
[source,xml]
#
def
upgrade(
self,
async_=None,
upgrade_action=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def upgrade( self, async_=None, upgrade_action=None, headers=None, query=None, wait=True, **kwargs ): """ Start or finish upgrade process for the cluster based on the action value. This action marks the cluster for upgrade or clears the upgrade running flag on the cluster based on the action value which takes values of start or stop. [source] ---- POST /ovirt-engine/api/clusters/123/upgrade ---- With a request body like this to mark the cluster for upgrade: [source,xml] ---- <action> <upgrade_action> start </upgrade_action> </action> ---- This method supports the following parameters: `upgrade_action`:: The action to be performed. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('upgrade_action', upgrade_action, types.ClusterUpgradeAction), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, upgrade_action=upgrade_action, ) # Send the request and wait for the response: return self._internal_action(action, 'upgrade', None, headers, query, wait)
Start or finish upgrade process for the cluster based on the action value. This action marks the cluster for upgrade or clears the upgrade running flag on the cluster based on the action value which takes values of start or stop.
[source]
POST /ovirt-engine/api/clusters/123/upgrade
With a request body like this to mark the cluster for upgrade:
[source,xml]
This method supports the following parameters:
upgrade_action:: The action to be performed.
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def affinity_groups_service(self): """ A reference to the service that manages affinity groups. """ return AffinityGroupsService(self._connection, '%s/affinitygroups' % self._path)
A reference to the service that manages affinity groups.
View Source
def cpu_profiles_service(self): """ A reference to the service that manages assigned CPU profiles for the cluster. """ return AssignedCpuProfilesService(self._connection, '%s/cpuprofiles' % self._path)
A reference to the service that manages assigned CPU profiles for the cluster.
View Source
def enabled_features_service(self): """ A reference to the service that manages the collection of enabled features for the cluster. """ return ClusterEnabledFeaturesService(self._connection, '%s/enabledfeatures' % self._path)
A reference to the service that manages the collection of enabled features for the cluster.
View Source
def external_network_providers_service(self): """ A reference to the service that manages the collection of external network providers. """ return ClusterExternalProvidersService(self._connection, '%s/externalnetworkproviders' % self._path)
A reference to the service that manages the collection of external network providers.
View Source
def gluster_hooks_service(self): """ A reference to the service that manages the Gluster hooks for the cluster. """ return GlusterHooksService(self._connection, '%s/glusterhooks' % self._path)
A reference to the service that manages the Gluster hooks for the cluster.
View Source
def gluster_volumes_service(self): """ A reference to the service that manages Gluster volumes for the cluster. """ return GlusterVolumesService(self._connection, '%s/glustervolumes' % self._path)
A reference to the service that manages Gluster volumes for the cluster.
View Source
def network_filters_service(self): """ A sub-collection with all the supported network filters for the cluster. """ return NetworkFiltersService(self._connection, '%s/networkfilters' % self._path)
A sub-collection with all the supported network filters for the cluster.
View Source
def networks_service(self): """ A reference to the service that manages assigned networks for the cluster. """ return ClusterNetworksService(self._connection, '%s/networks' % self._path)
A reference to the service that manages assigned networks for the cluster.
View Source
def permissions_service(self): """ A reference to permissions. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
A reference to permissions.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'affinitygroups': return self.affinity_groups_service() if path.startswith('affinitygroups/'): return self.affinity_groups_service().service(path[15:]) if path == 'cpuprofiles': return self.cpu_profiles_service() if path.startswith('cpuprofiles/'): return self.cpu_profiles_service().service(path[12:]) if path == 'enabledfeatures': return self.enabled_features_service() if path.startswith('enabledfeatures/'): return self.enabled_features_service().service(path[16:]) if path == 'externalnetworkproviders': return self.external_network_providers_service() if path.startswith('externalnetworkproviders/'): return self.external_network_providers_service().service(path[25:]) if path == 'glusterhooks': return self.gluster_hooks_service() if path.startswith('glusterhooks/'): return self.gluster_hooks_service().service(path[13:]) if path == 'glustervolumes': return self.gluster_volumes_service() if path.startswith('glustervolumes/'): return self.gluster_volumes_service().service(path[15:]) if path == 'networkfilters': return self.network_filters_service() if path.startswith('networkfilters/'): return self.network_filters_service().service(path[15:]) if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ClusterEnabledFeatureService(Service): """ Represents a feature enabled for the cluster. """ def __init__(self, connection, path): super(ClusterEnabledFeatureService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Provides the information about the cluster feature enabled. For example, to find details of the enabled feature `456` for cluster `123`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/123/enabledfeatures/456 ---- That will return a <<types/cluster_feature, ClusterFeature>> object containing the name: [source,xml] ---- <cluster_feature id="456"> <name>libgfapi_supported</name> </cluster_feature> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Disables a cluster feature. For example, to disable the feature `456` of cluster `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/clusters/123/enabledfeatures/456 ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ClusterEnabledFeatureService:%s' % self._path
Represents a feature enabled for the cluster.
View Source
def __init__(self, connection, path): super(ClusterEnabledFeatureService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Provides the information about the cluster feature enabled. For example, to find details of the enabled feature `456` for cluster `123`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/123/enabledfeatures/456 ---- That will return a <<types/cluster_feature, ClusterFeature>> object containing the name: [source,xml] ---- <cluster_feature id="456"> <name>libgfapi_supported</name> </cluster_feature> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Provides the information about the cluster feature enabled.
For example, to find details of the enabled feature 456 for cluster 123, send a request like this:
[source]
GET /ovirt-engine/api/clusters/123/enabledfeatures/456
That will return a <
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Disables a cluster feature. For example, to disable the feature `456` of cluster `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/clusters/123/enabledfeatures/456 ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Disables a cluster feature.
For example, to disable the feature 456 of cluster 123 send a request like this:
[source]
DELETE /ovirt-engine/api/clusters/123/enabledfeatures/456
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ClusterEnabledFeaturesService(Service): """ Provides information about the additional features that are enabled for this cluster. The features that are enabled are the available features for the cluster level """ def __init__(self, connection, path): super(ClusterEnabledFeaturesService, self).__init__(connection, path) self._feature_service = None def add( self, feature, headers=None, query=None, wait=True, **kwargs ): """ Enable an additional feature for a cluster. For example, to enable a feature `456` on cluster `123`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/123/enabledfeatures ---- The request body should look like this: [source,xml] ---- <cluster_feature id="456"/> ---- """ # Check the types of the parameters: Service._check_types([ ('feature', feature, types.ClusterFeature), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(feature, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the additional features enabled for the cluster. For example, to get the features enabled for cluster `123` send a request like this: [source] ---- GET /ovirt-engine/api/clusters/123/enabledfeatures ---- This will return a list of features: [source,xml] ---- <enabled_features> <cluster_feature id="123"> <name>test_feature</name> </cluster_feature> ... </enabled_features> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def feature_service(self, id): """ A reference to the service that provides information about a specific feature enabled for the cluster. """ Service._check_types([ ('id', id, str), ]) return ClusterEnabledFeatureService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.feature_service(path) return self.feature_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ClusterEnabledFeaturesService:%s' % self._path
Provides information about the additional features that are enabled for this cluster. The features that are enabled are the available features for the cluster level
View Source
def __init__(self, connection, path): super(ClusterEnabledFeaturesService, self).__init__(connection, path) self._feature_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, feature, headers=None, query=None, wait=True, **kwargs ): """ Enable an additional feature for a cluster. For example, to enable a feature `456` on cluster `123`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/123/enabledfeatures ---- The request body should look like this: [source,xml] ---- <cluster_feature id="456"/> ---- """ # Check the types of the parameters: Service._check_types([ ('feature', feature, types.ClusterFeature), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(feature, headers, query, wait)
Enable an additional feature for a cluster.
For example, to enable a feature 456 on cluster 123, send a request like this:
[source]
POST /ovirt-engine/api/clusters/123/enabledfeatures
The request body should look like this:
[source,xml]
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the additional features enabled for the cluster. For example, to get the features enabled for cluster `123` send a request like this: [source] ---- GET /ovirt-engine/api/clusters/123/enabledfeatures ---- This will return a list of features: [source,xml] ---- <enabled_features> <cluster_feature id="123"> <name>test_feature</name> </cluster_feature> ... </enabled_features> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists the additional features enabled for the cluster.
For example, to get the features enabled for cluster 123 send a request like this:
[source]
GET /ovirt-engine/api/clusters/123/enabledfeatures
This will return a list of features:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def feature_service(self, id): """ A reference to the service that provides information about a specific feature enabled for the cluster. """ Service._check_types([ ('id', id, str), ]) return ClusterEnabledFeatureService(self._connection, '%s/%s' % (self._path, id))
A reference to the service that provides information about a specific feature enabled for the cluster.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.feature_service(path) return self.feature_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ClusterExternalProvidersService(Service): """ This service lists external providers. """ def __init__(self, connection, path): super(ClusterExternalProvidersService, self).__init__(connection, path) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of external providers. The order of the returned list of providers is not guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ClusterExternalProvidersService:%s' % self._path
This service lists external providers.
View Source
def __init__(self, connection, path): super(ClusterExternalProvidersService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of external providers. The order of the returned list of providers is not guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of external providers. The order of the returned list of providers is not guaranteed.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ClusterFeatureService(Service): """ Represents a feature enabled for the cluster level """ def __init__(self, connection, path): super(ClusterFeatureService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Provides the information about the a cluster feature supported by a cluster level. For example, to find details of the cluster feature `456` for cluster level 4.1, send a request like this: [source] ---- GET /ovirt-engine/api/clusterlevels/4.1/clusterfeatures/456 ---- That will return a <<types/cluster_feature, ClusterFeature>> object containing the name: [source,xml] ---- <cluster_feature id="456"> <name>libgfapi_supported</name> </cluster_feature> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ClusterFeatureService:%s' % self._path
Represents a feature enabled for the cluster level
View Source
def __init__(self, connection, path): super(ClusterFeatureService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Provides the information about the a cluster feature supported by a cluster level. For example, to find details of the cluster feature `456` for cluster level 4.1, send a request like this: [source] ---- GET /ovirt-engine/api/clusterlevels/4.1/clusterfeatures/456 ---- That will return a <<types/cluster_feature, ClusterFeature>> object containing the name: [source,xml] ---- <cluster_feature id="456"> <name>libgfapi_supported</name> </cluster_feature> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Provides the information about the a cluster feature supported by a cluster level.
For example, to find details of the cluster feature 456 for cluster level 4.1, send a request like this:
[source]
GET /ovirt-engine/api/clusterlevels/4.1/clusterfeatures/456
That will return a <
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ClusterFeaturesService(Service): """ Provides information about the cluster features that are supported by a cluster level. """ def __init__(self, connection, path): super(ClusterFeaturesService, self).__init__(connection, path) self._feature_service = None def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the cluster features supported by the cluster level. [source] ---- GET /ovirt-engine/api/clusterlevels/4.1/clusterfeatures ---- This will return a list of cluster features supported by the cluster level: [source,xml] ---- <cluster_features> <cluster_feature id="123"> <name>test_feature</name> </cluster_feature> ... </cluster_features> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def feature_service(self, id): """ Reference to the service that provides information about a specific feature. """ Service._check_types([ ('id', id, str), ]) return ClusterFeatureService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.feature_service(path) return self.feature_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ClusterFeaturesService:%s' % self._path
Provides information about the cluster features that are supported by a cluster level.
View Source
def __init__(self, connection, path): super(ClusterFeaturesService, self).__init__(connection, path) self._feature_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the cluster features supported by the cluster level. [source] ---- GET /ovirt-engine/api/clusterlevels/4.1/clusterfeatures ---- This will return a list of cluster features supported by the cluster level: [source,xml] ---- <cluster_features> <cluster_feature id="123"> <name>test_feature</name> </cluster_feature> ... </cluster_features> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists the cluster features supported by the cluster level.
[source]
GET /ovirt-engine/api/clusterlevels/4.1/clusterfeatures
This will return a list of cluster features supported by the cluster level:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def feature_service(self, id): """ Reference to the service that provides information about a specific feature. """ Service._check_types([ ('id', id, str), ]) return ClusterFeatureService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that provides information about a specific feature.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.feature_service(path) return self.feature_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ClusterLevelService(Service): """ Provides information about a specific cluster level. See the <<services/cluster_levels,ClusterLevels>> service for more information. """ def __init__(self, connection, path): super(ClusterLevelService, self).__init__(connection, path) self._cluster_features_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Provides the information about the capabilities of the specific cluster level managed by this service. For example, to find what CPU types are supported by level 3.6 you can send a request like this: [source] ---- GET /ovirt-engine/api/clusterlevels/3.6 ---- That will return a <<types/cluster_level, ClusterLevel>> object containing the supported CPU types, and other information which describes the cluster level: [source,xml] ---- <cluster_level id="3.6"> <cpu_types> <cpu_type> <name>Intel Nehalem Family</name> <level>3</level> <architecture>x86_64</architecture> </cpu_type> ... </cpu_types> <permits> <permit id="1"> <name>create_vm</name> <administrative>false</administrative> </permit> ... </permits> </cluster_level> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def cluster_features_service(self): """ Reference to the service that manages the collection of supported features for this cluster level. """ return ClusterFeaturesService(self._connection, '%s/clusterfeatures' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'clusterfeatures': return self.cluster_features_service() if path.startswith('clusterfeatures/'): return self.cluster_features_service().service(path[16:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ClusterLevelService:%s' % self._path
Provides information about a specific cluster level. See the <
View Source
def __init__(self, connection, path): super(ClusterLevelService, self).__init__(connection, path) self._cluster_features_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Provides the information about the capabilities of the specific cluster level managed by this service. For example, to find what CPU types are supported by level 3.6 you can send a request like this: [source] ---- GET /ovirt-engine/api/clusterlevels/3.6 ---- That will return a <<types/cluster_level, ClusterLevel>> object containing the supported CPU types, and other information which describes the cluster level: [source,xml] ---- <cluster_level id="3.6"> <cpu_types> <cpu_type> <name>Intel Nehalem Family</name> <level>3</level> <architecture>x86_64</architecture> </cpu_type> ... </cpu_types> <permits> <permit id="1"> <name>create_vm</name> <administrative>false</administrative> </permit> ... </permits> </cluster_level> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Provides the information about the capabilities of the specific cluster level managed by this service. For example, to find what CPU types are supported by level 3.6 you can send a request like this:
[source]
GET /ovirt-engine/api/clusterlevels/3.6
That will return a <
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def cluster_features_service(self): """ Reference to the service that manages the collection of supported features for this cluster level. """ return ClusterFeaturesService(self._connection, '%s/clusterfeatures' % self._path)
Reference to the service that manages the collection of supported features for this cluster level.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'clusterfeatures': return self.cluster_features_service() if path.startswith('clusterfeatures/'): return self.cluster_features_service().service(path[16:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ClusterLevelsService(Service): """ Provides information about the capabilities of different cluster levels supported by the engine. Version 4.0 of the engine supports levels 4.0 and 3.6. Each of these levels support different sets of CPU types, for example. This service provides that information. """ def __init__(self, connection, path): super(ClusterLevelsService, self).__init__(connection, path) self._level_service = None def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the cluster levels supported by the system. [source] ---- GET /ovirt-engine/api/clusterlevels ---- This will return a list of available cluster levels. [source,xml] ---- <cluster_levels> <cluster_level id="4.0"> ... </cluster_level> ... </cluster_levels> ---- The order of the returned cluster levels isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def level_service(self, id): """ Reference to the service that provides information about an specific cluster level. """ Service._check_types([ ('id', id, str), ]) return ClusterLevelService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.level_service(path) return self.level_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ClusterLevelsService:%s' % self._path
Provides information about the capabilities of different cluster levels supported by the engine. Version 4.0 of the engine supports levels 4.0 and 3.6. Each of these levels support different sets of CPU types, for example. This service provides that information.
View Source
def __init__(self, connection, path): super(ClusterLevelsService, self).__init__(connection, path) self._level_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the cluster levels supported by the system. [source] ---- GET /ovirt-engine/api/clusterlevels ---- This will return a list of available cluster levels. [source,xml] ---- <cluster_levels> <cluster_level id="4.0"> ... </cluster_level> ... </cluster_levels> ---- The order of the returned cluster levels isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists the cluster levels supported by the system.
[source]
GET /ovirt-engine/api/clusterlevels
This will return a list of available cluster levels.
[source,xml]
The order of the returned cluster levels isn't guaranteed.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def level_service(self, id): """ Reference to the service that provides information about an specific cluster level. """ Service._check_types([ ('id', id, str), ]) return ClusterLevelService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that provides information about an specific cluster level.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.level_service(path) return self.level_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ClusterNetworkService(Service): """ A service to manage a specific cluster network. """ def __init__(self, connection, path): super(ClusterNetworkService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the cluster network details. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Unassigns the network from a cluster. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, network, headers=None, query=None, wait=True, **kwargs ): """ Updates the network in the cluster. This method supports the following parameters: `network`:: The cluster network. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(network, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ClusterNetworkService:%s' % self._path
A service to manage a specific cluster network.
View Source
def __init__(self, connection, path): super(ClusterNetworkService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the cluster network details. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the cluster network details.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Unassigns the network from a cluster. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Unassigns the network from a cluster.
View Source
def update( self, network, headers=None, query=None, wait=True, **kwargs ): """ Updates the network in the cluster. This method supports the following parameters: `network`:: The cluster network. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(network, headers, query, wait)
Updates the network in the cluster.
This method supports the following parameters:
network:: The cluster network.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ClusterNetworksService(Service): """ A service to manage cluster networks. """ def __init__(self, connection, path): super(ClusterNetworksService, self).__init__(connection, path) self._network_service = None def add( self, network, headers=None, query=None, wait=True, **kwargs ): """ Assigns the network to a cluster. Post a request like in the example below to assign the network to a cluster: [source] ---- POST /ovirt-engine/api/clusters/123/networks ---- Use the following example in its body: [source,xml] ---- <network id="123" /> ---- This method supports the following parameters: `network`:: The network object to be assigned to the cluster. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(network, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the networks that are assigned to the cluster. The order of the returned clusters isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified, all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def network_service(self, id): """ Access the cluster network service that manages the cluster network specified by an ID. """ Service._check_types([ ('id', id, str), ]) return ClusterNetworkService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ClusterNetworksService:%s' % self._path
A service to manage cluster networks.
View Source
def __init__(self, connection, path): super(ClusterNetworksService, self).__init__(connection, path) self._network_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, network, headers=None, query=None, wait=True, **kwargs ): """ Assigns the network to a cluster. Post a request like in the example below to assign the network to a cluster: [source] ---- POST /ovirt-engine/api/clusters/123/networks ---- Use the following example in its body: [source,xml] ---- <network id="123" /> ---- This method supports the following parameters: `network`:: The network object to be assigned to the cluster. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(network, headers, query, wait)
Assigns the network to a cluster. Post a request like in the example below to assign the network to a cluster:
[source]
POST /ovirt-engine/api/clusters/123/networks
Use the following example in its body:
[source,xml]
This method supports the following parameters:
network:: The network object to be assigned to the cluster.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the networks that are assigned to the cluster. The order of the returned clusters isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified, all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists the networks that are assigned to the cluster. The order of the returned clusters isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of networks to return. If not specified, all the networks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def network_service(self, id): """ Access the cluster network service that manages the cluster network specified by an ID. """ Service._check_types([ ('id', id, str), ]) return ClusterNetworkService(self._connection, '%s/%s' % (self._path, id))
Access the cluster network service that manages the cluster network specified by an ID.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ClustersService(Service): """ A service to manage clusters. """ def __init__(self, connection, path): super(ClustersService, self).__init__(connection, path) self._cluster_service = None def add( self, cluster, headers=None, query=None, wait=True, **kwargs ): """ Creates a new cluster. This requires the `name`, `cpu.type`, and `data_center` attributes. Identify the data center with either the `id` or `name` attribute. [source] ---- POST /ovirt-engine/api/clusters ---- With a request body like this: [source,xml] ---- <cluster> <name>mycluster</name> <cpu> <type>Intel Nehalem Family</type> </cpu> <data_center id="123"/> </cluster> ---- To create a cluster with an external network provider to be deployed on every host that is added to the cluster, send a request like this: [source] ---- POST /ovirt-engine/api/clusters ---- With a request body containing a reference to the desired provider: [source,xml] ---- <cluster> <name>mycluster</name> <cpu> <type>Intel Nehalem Family</type> </cpu> <data_center id="123"/> <external_network_providers> <external_provider name="ovirt-provider-ovn"/> </external_network_providers> </cluster> ---- """ # Check the types of the parameters: Service._check_types([ ('cluster', cluster, types.Cluster), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(cluster, headers, query, wait) def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of clusters of the system. The order of the returned clusters is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of clusters to return. If not specified, all the clusters are returned. `search`:: A query string used to restrict the returned clusters. `case_sensitive`:: Indicates if the search should be performed taking case into account. The default value is `true`, which means that case is taken into account. To search ignoring case, set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def cluster_service(self, id): """ A reference to the service that manages a specific cluster. """ Service._check_types([ ('id', id, str), ]) return ClusterService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.cluster_service(path) return self.cluster_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ClustersService:%s' % self._path
A service to manage clusters.
View Source
def __init__(self, connection, path): super(ClustersService, self).__init__(connection, path) self._cluster_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, cluster, headers=None, query=None, wait=True, **kwargs ): """ Creates a new cluster. This requires the `name`, `cpu.type`, and `data_center` attributes. Identify the data center with either the `id` or `name` attribute. [source] ---- POST /ovirt-engine/api/clusters ---- With a request body like this: [source,xml] ---- <cluster> <name>mycluster</name> <cpu> <type>Intel Nehalem Family</type> </cpu> <data_center id="123"/> </cluster> ---- To create a cluster with an external network provider to be deployed on every host that is added to the cluster, send a request like this: [source] ---- POST /ovirt-engine/api/clusters ---- With a request body containing a reference to the desired provider: [source,xml] ---- <cluster> <name>mycluster</name> <cpu> <type>Intel Nehalem Family</type> </cpu> <data_center id="123"/> <external_network_providers> <external_provider name="ovirt-provider-ovn"/> </external_network_providers> </cluster> ---- """ # Check the types of the parameters: Service._check_types([ ('cluster', cluster, types.Cluster), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(cluster, headers, query, wait)
Creates a new cluster.
This requires the name, cpu.type, and data_center attributes. Identify the data center with either the id
or name attribute.
[source]
POST /ovirt-engine/api/clusters
With a request body like this:
[source,xml]
To create a cluster with an external network provider to be deployed on every host that is added to the cluster, send a request like this:
[source]
POST /ovirt-engine/api/clusters
With a request body containing a reference to the desired provider:
[source,xml]
#
def
list(
self,
case_sensitive=None,
filter=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of clusters of the system. The order of the returned clusters is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of clusters to return. If not specified, all the clusters are returned. `search`:: A query string used to restrict the returned clusters. `case_sensitive`:: Indicates if the search should be performed taking case into account. The default value is `true`, which means that case is taken into account. To search ignoring case, set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of clusters of the system.
The order of the returned clusters is guaranteed only if the sortby clause is included in the
search parameter.
This method supports the following parameters:
max:: Sets the maximum number of clusters to return. If not specified, all the clusters are returned.
search:: A query string used to restrict the returned clusters.
case_sensitive:: Indicates if the search should be performed taking case into account.
The default value is true, which means that case is taken into account. To search
ignoring case, set it to false.
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def cluster_service(self, id): """ A reference to the service that manages a specific cluster. """ Service._check_types([ ('id', id, str), ]) return ClusterService(self._connection, '%s/%s' % (self._path, id))
A reference to the service that manages a specific cluster.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.cluster_service(path) return self.cluster_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class CopyableService(Service): """ """ def __init__(self, connection, path): super(CopyableService, self).__init__(connection, path) def copy( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the copy should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'CopyableService:%s' % self._path
View Source
def __init__(self, connection, path): super(CopyableService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def copy( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the copy should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the copy should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class CpuProfileService(Service): """ """ def __init__(self, connection, path): super(CpuProfileService, self).__init__(connection, path) self._permissions_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, profile, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified cpu profile in the system. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.CpuProfile), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(profile, headers, query, wait) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'CpuProfileService:%s' % self._path
View Source
def __init__(self, connection, path): super(CpuProfileService, self).__init__(connection, path) self._permissions_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, profile, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified cpu profile in the system. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.CpuProfile), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(profile, headers, query, wait)
Update the specified cpu profile in the system.
View Source
def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class CpuProfilesService(Service): """ """ def __init__(self, connection, path): super(CpuProfilesService, self).__init__(connection, path) self._profile_service = None def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new cpu profile to the system. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.CpuProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of CPU profiles of the system. The order of the returned list of CPU profiles is random. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified, all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return CpuProfileService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'CpuProfilesService:%s' % self._path
View Source
def __init__(self, connection, path): super(CpuProfilesService, self).__init__(connection, path) self._profile_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new cpu profile to the system. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.CpuProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait)
Add a new cpu profile to the system.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of CPU profiles of the system. The order of the returned list of CPU profiles is random. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified, all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of CPU profiles of the system. The order of the returned list of CPU profiles is random.
This method supports the following parameters:
max:: Sets the maximum number of profiles to return. If not specified, all the profiles are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return CpuProfileService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DataCenterService(Service): """ A service to manage a data center. """ def __init__(self, connection, path): super(DataCenterService, self).__init__(connection, path) self._clusters_service = None self._iscsi_bonds_service = None self._networks_service = None self._permissions_service = None self._qoss_service = None self._quotas_service = None self._storage_domains_service = None def clean_finished_tasks( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Currently, the storage pool manager (SPM) fails to switch to another host if the SPM has uncleared tasks. Clearing all finished tasks enables the SPM switching. For example, to clean all the finished tasks on a data center with ID `123` send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/cleanfinishedtasks ---- With a request body like this: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'cleanfinishedtasks', None, headers, query, wait) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get a data center. An example of getting a data center: [source] ---- GET /ovirt-engine/api/datacenters/123 ---- [source,xml] ---- <data_center href="/ovirt-engine/api/datacenters/123" id="123"> <name>Default</name> <description>The default Data Center</description> <link href="/ovirt-engine/api/datacenters/123/clusters" rel="clusters"/> <link href="/ovirt-engine/api/datacenters/123/storagedomains" rel="storagedomains"/> <link href="/ovirt-engine/api/datacenters/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/datacenters/123/networks" rel="networks"/> <link href="/ovirt-engine/api/datacenters/123/quotas" rel="quotas"/> <link href="/ovirt-engine/api/datacenters/123/qoss" rel="qoss"/> <link href="/ovirt-engine/api/datacenters/123/iscsibonds" rel="iscsibonds"/> <local>false</local> <quota_mode>disabled</quota_mode> <status>up</status> <storage_format>v3</storage_format> <supported_versions> <version> <major>4</major> <minor>0</minor> </version> </supported_versions> <version> <major>4</major> <minor>0</minor> </version> <mac_pool href="/ovirt-engine/api/macpools/456" id="456"/> </data_center> ---- This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, force=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the data center. [source] ---- DELETE /ovirt-engine/api/datacenters/123 ---- Without any special parameters, the storage domains attached to the data center are detached and then removed from the storage. If something fails when performing this operation, for example if there is no host available to remove the storage domains from the storage, the complete operation will fail. If the `force` parameter is `true` then the operation will always succeed, even if something fails while removing one storage domain, for example. The failure is just ignored and the data center is removed from the database anyway. This method supports the following parameters: `force`:: Indicates if the operation should succeed, and the storage domain removed from the database, even if something fails during the operation. This parameter is optional, and the default value is `false`. `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('force', force, bool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if force is not None: force = Writer.render_boolean(force) query['force'] = force if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def set_master( self, async_=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Used for manually setting a storage domain in the data center as a master. For example, for setting a storage domain with ID '456' as a master on a data center with ID '123', send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/setmaster ---- With a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> </action> ---- The new master storage domain can be also specified by its name. This method supports the following parameters: `storage_domain`:: The new master storage domain for the data center. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'setmaster', None, headers, query, wait) def update( self, data_center, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the data center. The `name`, `description`, `storage_type`, `version`, `storage_format` and `mac_pool` elements are updatable post-creation. For example, to change the name and description of data center `123` send a request like this: [source] ---- PUT /ovirt-engine/api/datacenters/123 ---- With a request body like this: [source,xml] ---- <data_center> <name>myupdatedname</name> <description>An updated description for the data center</description> </data_center> ---- This method supports the following parameters: `data_center`:: The data center that is being updated. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('data_center', data_center, types.DataCenter), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(data_center, headers, query, wait) def clusters_service(self): """ """ return ClustersService(self._connection, '%s/clusters' % self._path) def iscsi_bonds_service(self): """ Reference to the iSCSI bonds service. """ return IscsiBondsService(self._connection, '%s/iscsibonds' % self._path) def networks_service(self): """ Returns a reference to the service, that manages the networks, that are associated with the data center. """ return DataCenterNetworksService(self._connection, '%s/networks' % self._path) def permissions_service(self): """ Reference to the permissions service. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def qoss_service(self): """ Reference to the QOSs service. """ return QossService(self._connection, '%s/qoss' % self._path) def quotas_service(self): """ Reference to the quotas service. """ return QuotasService(self._connection, '%s/quotas' % self._path) def storage_domains_service(self): """ Attach and detach storage domains to and from a data center. For attaching a single storage domain we should use the following POST request: [source] ---- POST /ovirt-engine/api/datacenters/123/storagedomains ---- With a request body like this: [source,xml] ---- <storage_domain> <name>data1</name> </storage_domain> ---- For detaching a single storage domain we should use the following DELETE request: [source] ---- DELETE /ovirt-engine/api/datacenters/123/storagedomains/123 ---- """ return AttachedStorageDomainsService(self._connection, '%s/storagedomains' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'clusters': return self.clusters_service() if path.startswith('clusters/'): return self.clusters_service().service(path[9:]) if path == 'iscsibonds': return self.iscsi_bonds_service() if path.startswith('iscsibonds/'): return self.iscsi_bonds_service().service(path[11:]) if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'qoss': return self.qoss_service() if path.startswith('qoss/'): return self.qoss_service().service(path[5:]) if path == 'quotas': return self.quotas_service() if path.startswith('quotas/'): return self.quotas_service().service(path[7:]) if path == 'storagedomains': return self.storage_domains_service() if path.startswith('storagedomains/'): return self.storage_domains_service().service(path[15:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DataCenterService:%s' % self._path
A service to manage a data center.
View Source
def __init__(self, connection, path): super(DataCenterService, self).__init__(connection, path) self._clusters_service = None self._iscsi_bonds_service = None self._networks_service = None self._permissions_service = None self._qoss_service = None self._quotas_service = None self._storage_domains_service = None
Creates a new service that will use the given connection and path.
View Source
def clean_finished_tasks( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Currently, the storage pool manager (SPM) fails to switch to another host if the SPM has uncleared tasks. Clearing all finished tasks enables the SPM switching. For example, to clean all the finished tasks on a data center with ID `123` send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/cleanfinishedtasks ---- With a request body like this: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'cleanfinishedtasks', None, headers, query, wait)
Currently, the storage pool manager (SPM) fails to
switch to another host if the SPM has uncleared tasks.
Clearing all finished tasks enables the SPM switching.
For example, to clean all the finished tasks on a data center with ID 123 send a request like this:
[source]
POST /ovirt-engine/api/datacenters/123/cleanfinishedtasks
With a request body like this:
[source,xml]
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get a data center. An example of getting a data center: [source] ---- GET /ovirt-engine/api/datacenters/123 ---- [source,xml] ---- <data_center href="/ovirt-engine/api/datacenters/123" id="123"> <name>Default</name> <description>The default Data Center</description> <link href="/ovirt-engine/api/datacenters/123/clusters" rel="clusters"/> <link href="/ovirt-engine/api/datacenters/123/storagedomains" rel="storagedomains"/> <link href="/ovirt-engine/api/datacenters/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/datacenters/123/networks" rel="networks"/> <link href="/ovirt-engine/api/datacenters/123/quotas" rel="quotas"/> <link href="/ovirt-engine/api/datacenters/123/qoss" rel="qoss"/> <link href="/ovirt-engine/api/datacenters/123/iscsibonds" rel="iscsibonds"/> <local>false</local> <quota_mode>disabled</quota_mode> <status>up</status> <storage_format>v3</storage_format> <supported_versions> <version> <major>4</major> <minor>0</minor> </version> </supported_versions> <version> <major>4</major> <minor>0</minor> </version> <mac_pool href="/ovirt-engine/api/macpools/456" id="456"/> </data_center> ---- This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get a data center. An example of getting a data center:
[source]
GET /ovirt-engine/api/datacenters/123
[source,xml]
This method supports the following parameters:
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, force=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the data center. [source] ---- DELETE /ovirt-engine/api/datacenters/123 ---- Without any special parameters, the storage domains attached to the data center are detached and then removed from the storage. If something fails when performing this operation, for example if there is no host available to remove the storage domains from the storage, the complete operation will fail. If the `force` parameter is `true` then the operation will always succeed, even if something fails while removing one storage domain, for example. The failure is just ignored and the data center is removed from the database anyway. This method supports the following parameters: `force`:: Indicates if the operation should succeed, and the storage domain removed from the database, even if something fails during the operation. This parameter is optional, and the default value is `false`. `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('force', force, bool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if force is not None: force = Writer.render_boolean(force) query['force'] = force if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the data center.
[source]
DELETE /ovirt-engine/api/datacenters/123
Without any special parameters, the storage domains attached to the data center are detached and then removed
from the storage. If something fails when performing this operation, for example if there is no host available to
remove the storage domains from the storage, the complete operation will fail.
If the force parameter is true then the operation will always succeed, even if something fails while removing
one storage domain, for example. The failure is just ignored and the data center is removed from the database
anyway.
This method supports the following parameters:
force:: Indicates if the operation should succeed, and the storage domain removed from the database, even if
something fails during the operation.
This parameter is optional, and the default value is false.
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
set_master(
self,
async_=None,
storage_domain=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def set_master( self, async_=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Used for manually setting a storage domain in the data center as a master. For example, for setting a storage domain with ID '456' as a master on a data center with ID '123', send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/setmaster ---- With a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> </action> ---- The new master storage domain can be also specified by its name. This method supports the following parameters: `storage_domain`:: The new master storage domain for the data center. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'setmaster', None, headers, query, wait)
Used for manually setting a storage domain in the data center as a master. For example, for setting a storage domain with ID '456' as a master on a data center with ID '123', send a request like this:
[source]
POST /ovirt-engine/api/datacenters/123/setmaster
With a request body like this:
[source,xml]
The new master storage domain can be also specified by its name.
This method supports the following parameters:
storage_domain:: The new master storage domain for the data center.
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, data_center, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the data center. The `name`, `description`, `storage_type`, `version`, `storage_format` and `mac_pool` elements are updatable post-creation. For example, to change the name and description of data center `123` send a request like this: [source] ---- PUT /ovirt-engine/api/datacenters/123 ---- With a request body like this: [source,xml] ---- <data_center> <name>myupdatedname</name> <description>An updated description for the data center</description> </data_center> ---- This method supports the following parameters: `data_center`:: The data center that is being updated. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('data_center', data_center, types.DataCenter), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(data_center, headers, query, wait)
Updates the data center.
The name, description, storage_type, version, storage_format and mac_pool elements are updatable
post-creation. For example, to change the name and description of data center 123 send a request like this:
[source]
PUT /ovirt-engine/api/datacenters/123
With a request body like this:
[source,xml]
This method supports the following parameters:
data_center:: The data center that is being updated.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def clusters_service(self): """ """ return ClustersService(self._connection, '%s/clusters' % self._path)
View Source
def iscsi_bonds_service(self): """ Reference to the iSCSI bonds service. """ return IscsiBondsService(self._connection, '%s/iscsibonds' % self._path)
Reference to the iSCSI bonds service.
View Source
def networks_service(self): """ Returns a reference to the service, that manages the networks, that are associated with the data center. """ return DataCenterNetworksService(self._connection, '%s/networks' % self._path)
Returns a reference to the service, that manages the networks, that are associated with the data center.
View Source
def permissions_service(self): """ Reference to the permissions service. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
Reference to the permissions service.
View Source
def qoss_service(self): """ Reference to the QOSs service. """ return QossService(self._connection, '%s/qoss' % self._path)
Reference to the QOSs service.
View Source
def quotas_service(self): """ Reference to the quotas service. """ return QuotasService(self._connection, '%s/quotas' % self._path)
Reference to the quotas service.
View Source
def storage_domains_service(self): """ Attach and detach storage domains to and from a data center. For attaching a single storage domain we should use the following POST request: [source] ---- POST /ovirt-engine/api/datacenters/123/storagedomains ---- With a request body like this: [source,xml] ---- <storage_domain> <name>data1</name> </storage_domain> ---- For detaching a single storage domain we should use the following DELETE request: [source] ---- DELETE /ovirt-engine/api/datacenters/123/storagedomains/123 ---- """ return AttachedStorageDomainsService(self._connection, '%s/storagedomains' % self._path)
Attach and detach storage domains to and from a data center. For attaching a single storage domain we should use the following POST request:
[source]
POST /ovirt-engine/api/datacenters/123/storagedomains
With a request body like this:
[source,xml]
For detaching a single storage domain we should use the following DELETE request:
[source]
DELETE /ovirt-engine/api/datacenters/123/storagedomains/123
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'clusters': return self.clusters_service() if path.startswith('clusters/'): return self.clusters_service().service(path[9:]) if path == 'iscsibonds': return self.iscsi_bonds_service() if path.startswith('iscsibonds/'): return self.iscsi_bonds_service().service(path[11:]) if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'qoss': return self.qoss_service() if path.startswith('qoss/'): return self.qoss_service().service(path[5:]) if path == 'quotas': return self.quotas_service() if path.startswith('quotas/'): return self.quotas_service().service(path[7:]) if path == 'storagedomains': return self.storage_domains_service() if path.startswith('storagedomains/'): return self.storage_domains_service().service(path[15:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DataCenterNetworkService(Service): """ A service to manage a specific data center network. """ def __init__(self, connection, path): super(DataCenterNetworkService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the data center network details. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes the network. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, network, headers=None, query=None, wait=True, **kwargs ): """ Updates the network in the data center. This method supports the following parameters: `network`:: The data center network. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(network, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DataCenterNetworkService:%s' % self._path
A service to manage a specific data center network.
View Source
def __init__(self, connection, path): super(DataCenterNetworkService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the data center network details. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the data center network details.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes the network. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the network.
View Source
def update( self, network, headers=None, query=None, wait=True, **kwargs ): """ Updates the network in the data center. This method supports the following parameters: `network`:: The data center network. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(network, headers, query, wait)
Updates the network in the data center.
This method supports the following parameters:
network:: The data center network.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DataCenterNetworksService(Service): """ A service to manage data center networks. """ def __init__(self, connection, path): super(DataCenterNetworksService, self).__init__(connection, path) self._network_service = None def add( self, network, headers=None, query=None, wait=True, **kwargs ): """ Create a new network in a data center. Post a request like in the example below to create a new network in a data center with an ID of `123`. [source] ---- POST /ovirt-engine/api/datacenters/123/networks ---- Use the following example in its body: [source,xml] ---- <network> <name>mynetwork</name> </network> ---- This method supports the following parameters: `network`:: The network object to be created in the data center. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(network, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists networks in the data center. The order of the returned list of networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified, all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def network_service(self, id): """ Access the data center network service that manages the data center network specified by an ID. """ Service._check_types([ ('id', id, str), ]) return DataCenterNetworkService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DataCenterNetworksService:%s' % self._path
A service to manage data center networks.
View Source
def __init__(self, connection, path): super(DataCenterNetworksService, self).__init__(connection, path) self._network_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, network, headers=None, query=None, wait=True, **kwargs ): """ Create a new network in a data center. Post a request like in the example below to create a new network in a data center with an ID of `123`. [source] ---- POST /ovirt-engine/api/datacenters/123/networks ---- Use the following example in its body: [source,xml] ---- <network> <name>mynetwork</name> </network> ---- This method supports the following parameters: `network`:: The network object to be created in the data center. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(network, headers, query, wait)
Create a new network in a data center.
Post a request like in the example below to create a new network in a data center with an ID of 123.
[source]
POST /ovirt-engine/api/datacenters/123/networks
Use the following example in its body:
[source,xml]
This method supports the following parameters:
network:: The network object to be created in the data center.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists networks in the data center. The order of the returned list of networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified, all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists networks in the data center. The order of the returned list of networks isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of networks to return. If not specified, all the networks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def network_service(self, id): """ Access the data center network service that manages the data center network specified by an ID. """ Service._check_types([ ('id', id, str), ]) return DataCenterNetworkService(self._connection, '%s/%s' % (self._path, id))
Access the data center network service that manages the data center network specified by an ID.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DataCentersService(Service): """ A service to manage data centers. """ def __init__(self, connection, path): super(DataCentersService, self).__init__(connection, path) self._data_center_service = None def add( self, data_center, headers=None, query=None, wait=True, **kwargs ): """ Creates a new data center. Creation of a new data center requires the `name` and `local` elements. For example, to create a data center named `mydc` that uses shared storage (NFS, iSCSI or fibre channel) send a request like this: [source] ---- POST /ovirt-engine/api/datacenters ---- With a request body like this: [source,xml] ---- <data_center> <name>mydc</name> <local>false</local> </data_center> ---- This method supports the following parameters: `data_center`:: The data center that is being added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('data_center', data_center, types.DataCenter), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(data_center, headers, query, wait) def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the data centers. The following request retrieves a representation of the data centers: [source] ---- GET /ovirt-engine/api/datacenters ---- The above request performed with `curl`: [source,bash] ---- curl \ --request GET \ --cacert /etc/pki/ovirt-engine/ca.pem \ --header "Version: 4" \ --header "Accept: application/xml" \ --user "admin@internal:mypassword" \ https://myengine.example.com/ovirt-engine/api/datacenters ---- This is what an example response could look like: [source,xml] ---- <data_center href="/ovirt-engine/api/datacenters/123" id="123"> <name>Default</name> <description>The default Data Center</description> <link href="/ovirt-engine/api/datacenters/123/networks" rel="networks"/> <link href="/ovirt-engine/api/datacenters/123/storagedomains" rel="storagedomains"/> <link href="/ovirt-engine/api/datacenters/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/datacenters/123/clusters" rel="clusters"/> <link href="/ovirt-engine/api/datacenters/123/qoss" rel="qoss"/> <link href="/ovirt-engine/api/datacenters/123/iscsibonds" rel="iscsibonds"/> <link href="/ovirt-engine/api/datacenters/123/quotas" rel="quotas"/> <local>false</local> <quota_mode>disabled</quota_mode> <status>up</status> <supported_versions> <version> <major>4</major> <minor>0</minor> </version> </supported_versions> <version> <major>4</major> <minor>0</minor> </version> </data_center> ---- Note the `id` code of your `Default` data center. This code identifies this data center in relation to other resources of your virtual environment. The data center also contains a link to the storage domains collection. The data center uses this collection to attach storage domains from the storage domains main collection. The order of the returned list of data centers is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of data centers to return. If not specified all the data centers are returned. `search`:: A query string used to restrict the returned data centers. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def data_center_service(self, id): """ Reference to the service that manages a specific data center. """ Service._check_types([ ('id', id, str), ]) return DataCenterService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.data_center_service(path) return self.data_center_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DataCentersService:%s' % self._path
A service to manage data centers.
View Source
def __init__(self, connection, path): super(DataCentersService, self).__init__(connection, path) self._data_center_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, data_center, headers=None, query=None, wait=True, **kwargs ): """ Creates a new data center. Creation of a new data center requires the `name` and `local` elements. For example, to create a data center named `mydc` that uses shared storage (NFS, iSCSI or fibre channel) send a request like this: [source] ---- POST /ovirt-engine/api/datacenters ---- With a request body like this: [source,xml] ---- <data_center> <name>mydc</name> <local>false</local> </data_center> ---- This method supports the following parameters: `data_center`:: The data center that is being added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('data_center', data_center, types.DataCenter), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(data_center, headers, query, wait)
Creates a new data center.
Creation of a new data center requires the name and local elements. For example, to create a data center
named mydc that uses shared storage (NFS, iSCSI or fibre channel) send a request like this:
[source]
POST /ovirt-engine/api/datacenters
With a request body like this:
[source,xml]
This method supports the following parameters:
data_center:: The data center that is being added.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
list(
self,
case_sensitive=None,
filter=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the data centers. The following request retrieves a representation of the data centers: [source] ---- GET /ovirt-engine/api/datacenters ---- The above request performed with `curl`: [source,bash] ---- curl \ --request GET \ --cacert /etc/pki/ovirt-engine/ca.pem \ --header "Version: 4" \ --header "Accept: application/xml" \ --user "admin@internal:mypassword" \ https://myengine.example.com/ovirt-engine/api/datacenters ---- This is what an example response could look like: [source,xml] ---- <data_center href="/ovirt-engine/api/datacenters/123" id="123"> <name>Default</name> <description>The default Data Center</description> <link href="/ovirt-engine/api/datacenters/123/networks" rel="networks"/> <link href="/ovirt-engine/api/datacenters/123/storagedomains" rel="storagedomains"/> <link href="/ovirt-engine/api/datacenters/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/datacenters/123/clusters" rel="clusters"/> <link href="/ovirt-engine/api/datacenters/123/qoss" rel="qoss"/> <link href="/ovirt-engine/api/datacenters/123/iscsibonds" rel="iscsibonds"/> <link href="/ovirt-engine/api/datacenters/123/quotas" rel="quotas"/> <local>false</local> <quota_mode>disabled</quota_mode> <status>up</status> <supported_versions> <version> <major>4</major> <minor>0</minor> </version> </supported_versions> <version> <major>4</major> <minor>0</minor> </version> </data_center> ---- Note the `id` code of your `Default` data center. This code identifies this data center in relation to other resources of your virtual environment. The data center also contains a link to the storage domains collection. The data center uses this collection to attach storage domains from the storage domains main collection. The order of the returned list of data centers is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of data centers to return. If not specified all the data centers are returned. `search`:: A query string used to restrict the returned data centers. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists the data centers. The following request retrieves a representation of the data centers:
[source]
GET /ovirt-engine/api/datacenters
The above request performed with curl:
[source,bash]
curl --request GET --cacert /etc/pki/ovirt-engine/ca.pem --header "Version: 4" --header "Accept: application/xml" --user "admin@internal:mypassword" https://myengine.example.com/ovirt-engine/api/datacenters
This is what an example response could look like:
[source,xml]
Note the id code of your Default data center. This code identifies this data center in relation to other
resources of your virtual environment.
The data center also contains a link to the storage domains collection. The data center uses this collection to
attach storage domains from the storage domains main collection.
The order of the returned list of data centers is guaranteed only if the sortby clause is included in the
search parameter.
This method supports the following parameters:
max:: Sets the maximum number of data centers to return. If not specified all the data centers are returned.
search:: A query string used to restrict the returned data centers.
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def data_center_service(self, id): """ Reference to the service that manages a specific data center. """ Service._check_types([ ('id', id, str), ]) return DataCenterService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages a specific data center.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.data_center_service(path) return self.data_center_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DiskAttachmentService(Service): """ This service manages the attachment of a disk to a virtual machine. """ def __init__(self, connection, path): super(DiskAttachmentService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the details of the attachment, including the bootable flag and link to the disk. An example of getting a disk attachment: [source] ---- GET /ovirt-engine/api/vms/123/diskattachments/456 ---- [source,xml] ---- <disk_attachment href="/ovirt-engine/api/vms/123/diskattachments/456" id="456"> <active>true</active> <bootable>true</bootable> <interface>virtio</interface> <disk href="/ovirt-engine/api/disks/456" id="456"/> <vm href="/ovirt-engine/api/vms/123" id="123"/> </disk_attachment> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, detach_only=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the disk attachment. This will only detach the disk from the virtual machine, but won't remove it from the system, unless the `detach_only` parameter is `false`. An example of removing a disk attachment: [source] ---- DELETE /ovirt-engine/api/vms/123/diskattachments/456?detach_only=true ---- This method supports the following parameters: `detach_only`:: Indicates if the disk should only be detached from the virtual machine, but not removed from the system. The default value is `true`, which won't remove the disk from the system. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('detach_only', detach_only, bool), ]) # Build the URL: query = query or {} if detach_only is not None: detach_only = Writer.render_boolean(detach_only) query['detach_only'] = detach_only # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, disk_attachment, headers=None, query=None, wait=True, **kwargs ): """ Update the disk attachment and the disk properties within it. [source] ---- PUT /vms/{vm:id}/disksattachments/{attachment:id} <disk_attachment> <bootable>true</bootable> <interface>ide</interface> <active>true</active> <disk> <name>mydisk</name> <provisioned_size>1024</provisioned_size> ... </disk> </disk_attachment> ---- """ # Check the types of the parameters: Service._check_types([ ('disk_attachment', disk_attachment, types.DiskAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(disk_attachment, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DiskAttachmentService:%s' % self._path
This service manages the attachment of a disk to a virtual machine.
View Source
def __init__(self, connection, path): super(DiskAttachmentService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the details of the attachment, including the bootable flag and link to the disk. An example of getting a disk attachment: [source] ---- GET /ovirt-engine/api/vms/123/diskattachments/456 ---- [source,xml] ---- <disk_attachment href="/ovirt-engine/api/vms/123/diskattachments/456" id="456"> <active>true</active> <bootable>true</bootable> <interface>virtio</interface> <disk href="/ovirt-engine/api/disks/456" id="456"/> <vm href="/ovirt-engine/api/vms/123" id="123"/> </disk_attachment> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the details of the attachment, including the bootable flag and link to the disk. An example of getting a disk attachment:
[source]
GET /ovirt-engine/api/vms/123/diskattachments/456
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, detach_only=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the disk attachment. This will only detach the disk from the virtual machine, but won't remove it from the system, unless the `detach_only` parameter is `false`. An example of removing a disk attachment: [source] ---- DELETE /ovirt-engine/api/vms/123/diskattachments/456?detach_only=true ---- This method supports the following parameters: `detach_only`:: Indicates if the disk should only be detached from the virtual machine, but not removed from the system. The default value is `true`, which won't remove the disk from the system. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('detach_only', detach_only, bool), ]) # Build the URL: query = query or {} if detach_only is not None: detach_only = Writer.render_boolean(detach_only) query['detach_only'] = detach_only # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the disk attachment.
This will only detach the disk from the virtual machine, but won't remove it from
the system, unless the detach_only parameter is false.
An example of removing a disk attachment:
[source]
DELETE /ovirt-engine/api/vms/123/diskattachments/456?detach_only=true
This method supports the following parameters:
detach_only:: Indicates if the disk should only be detached from the virtual machine, but not removed from the system.
The default value is true, which won't remove the disk from the system.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, disk_attachment, headers=None, query=None, wait=True, **kwargs ): """ Update the disk attachment and the disk properties within it. [source] ---- PUT /vms/{vm:id}/disksattachments/{attachment:id} <disk_attachment> <bootable>true</bootable> <interface>ide</interface> <active>true</active> <disk> <name>mydisk</name> <provisioned_size>1024</provisioned_size> ... </disk> </disk_attachment> ---- """ # Check the types of the parameters: Service._check_types([ ('disk_attachment', disk_attachment, types.DiskAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(disk_attachment, headers, query, wait)
Update the disk attachment and the disk properties within it.
[source]
PUT /vms/{vm:id}/disksattachments/{attachment:id}
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DiskAttachmentsService(Service): """ This service manages the set of disks attached to a virtual machine. Each attached disk is represented by a <<types/disk_attachment,DiskAttachment>>, containing the bootable flag, the disk interface and the reference to the disk. """ def __init__(self, connection, path): super(DiskAttachmentsService, self).__init__(connection, path) self._attachment_service = None def add( self, attachment, headers=None, query=None, wait=True, **kwargs ): """ Adds a new disk attachment to the virtual machine. The `attachment` parameter can contain just a reference, if the disk already exists: [source,xml] ---- <disk_attachment> <bootable>true</bootable> <pass_discard>true</pass_discard> <interface>ide</interface> <active>true</active> <disk id="123"/> </disk_attachment> ---- Or it can contain the complete representation of the disk, if the disk doesn't exist yet: [source,xml] ---- <disk_attachment> <bootable>true</bootable> <pass_discard>true</pass_discard> <interface>ide</interface> <active>true</active> <disk> <name>mydisk</name> <provisioned_size>1024</provisioned_size> ... </disk> </disk_attachment> ---- In this case the disk will be created and then attached to the virtual machine. In both cases, use the following URL for a virtual machine with an id `345`: [source] ---- POST /ovirt-engine/api/vms/345/diskattachments ---- IMPORTANT: The server accepts requests that don't contain the `active` attribute, but the effect is undefined. In some cases the disk will be automatically activated and in other cases it won't. To avoid issues it is strongly recommended to always include the `active` attribute with the desired value. This method supports the following parameters: `attachment`:: The disk attachment to add to the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.DiskAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(attachment, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List the disk that are attached to the virtual machine. The order of the returned list of disks attachments isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def add_providing_disk_id( self, attachment, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `attachment`:: The disk attachment to add to the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.DiskAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(attachment, headers, query, wait) def add_signature1( self, attachment, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `attachment`:: The disk attachment to add to the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.DiskAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(attachment, headers, query, wait) def attachment_service(self, id): """ Reference to the service that manages a specific attachment. """ Service._check_types([ ('id', id, str), ]) return DiskAttachmentService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.attachment_service(path) return self.attachment_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DiskAttachmentsService:%s' % self._path
This service manages the set of disks attached to a virtual machine. Each attached disk is represented by a
<
View Source
def __init__(self, connection, path): super(DiskAttachmentsService, self).__init__(connection, path) self._attachment_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, attachment, headers=None, query=None, wait=True, **kwargs ): """ Adds a new disk attachment to the virtual machine. The `attachment` parameter can contain just a reference, if the disk already exists: [source,xml] ---- <disk_attachment> <bootable>true</bootable> <pass_discard>true</pass_discard> <interface>ide</interface> <active>true</active> <disk id="123"/> </disk_attachment> ---- Or it can contain the complete representation of the disk, if the disk doesn't exist yet: [source,xml] ---- <disk_attachment> <bootable>true</bootable> <pass_discard>true</pass_discard> <interface>ide</interface> <active>true</active> <disk> <name>mydisk</name> <provisioned_size>1024</provisioned_size> ... </disk> </disk_attachment> ---- In this case the disk will be created and then attached to the virtual machine. In both cases, use the following URL for a virtual machine with an id `345`: [source] ---- POST /ovirt-engine/api/vms/345/diskattachments ---- IMPORTANT: The server accepts requests that don't contain the `active` attribute, but the effect is undefined. In some cases the disk will be automatically activated and in other cases it won't. To avoid issues it is strongly recommended to always include the `active` attribute with the desired value. This method supports the following parameters: `attachment`:: The disk attachment to add to the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.DiskAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(attachment, headers, query, wait)
Adds a new disk attachment to the virtual machine. The attachment parameter can contain just a reference, if
the disk already exists:
[source,xml]
Or it can contain the complete representation of the disk, if the disk doesn't exist yet:
[source,xml]
In this case the disk will be created and then attached to the virtual machine.
In both cases, use the following URL for a virtual machine with an id 345:
[source]
POST /ovirt-engine/api/vms/345/diskattachments
IMPORTANT: The server accepts requests that don't contain the active attribute, but the effect is
undefined. In some cases the disk will be automatically activated and in other cases it won't. To
avoid issues it is strongly recommended to always include the active attribute with the desired
value.
This method supports the following parameters:
attachment:: The disk attachment to add to the virtual machine.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List the disk that are attached to the virtual machine. The order of the returned list of disks attachments isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List the disk that are attached to the virtual machine. The order of the returned list of disks attachments isn't guaranteed.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_providing_disk_id( self, attachment, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `attachment`:: The disk attachment to add to the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.DiskAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(attachment, headers, query, wait)
This method supports the following parameters:
attachment:: The disk attachment to add to the virtual machine.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_signature1( self, attachment, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `attachment`:: The disk attachment to add to the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.DiskAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(attachment, headers, query, wait)
This method supports the following parameters:
attachment:: The disk attachment to add to the virtual machine.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def attachment_service(self, id): """ Reference to the service that manages a specific attachment. """ Service._check_types([ ('id', id, str), ]) return DiskAttachmentService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages a specific attachment.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.attachment_service(path) return self.attachment_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DiskProfileService(Service): """ """ def __init__(self, connection, path): super(DiskProfileService, self).__init__(connection, path) self._permissions_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, profile, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified disk profile in the system. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.DiskProfile), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(profile, headers, query, wait) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DiskProfileService:%s' % self._path
View Source
def __init__(self, connection, path): super(DiskProfileService, self).__init__(connection, path) self._permissions_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, profile, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified disk profile in the system. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.DiskProfile), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(profile, headers, query, wait)
Update the specified disk profile in the system.
View Source
def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DiskProfilesService(Service): """ """ def __init__(self, connection, path): super(DiskProfilesService, self).__init__(connection, path) self._disk_profile_service = None def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new disk profile to the system. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.DiskProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disk profiles of the system. The order of the returned list of disk profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return DiskProfileService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_profile_service(path) return self.disk_profile_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DiskProfilesService:%s' % self._path
View Source
def __init__(self, connection, path): super(DiskProfilesService, self).__init__(connection, path) self._disk_profile_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a new disk profile to the system. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.DiskProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait)
Add a new disk profile to the system.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disk profiles of the system. The order of the returned list of disk profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of disk profiles of the system. The order of the returned list of disk profiles isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of profiles to return. If not specified all the profiles are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disk_profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return DiskProfileService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_profile_service(path) return self.disk_profile_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DiskSnapshotService(Service): """ """ def __init__(self, connection, path): super(DiskSnapshotService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DiskSnapshotService:%s' % self._path
View Source
def __init__(self, connection, path): super(DiskSnapshotService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DiskSnapshotsService(Service): """ Manages the collection of disk snapshots available in an storage domain. """ def __init__(self, connection, path): super(DiskSnapshotsService, self).__init__(connection, path) self._snapshot_service = None def list( self, follow=None, include_active=None, include_template=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disk snapshots of the storage domain. The order of the returned list of disk snapshots isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of snapshots to return. If not specified all the snapshots are returned. `include_active`:: If true return also active snapshots. If not specified active snapshots are not returned. `include_template`:: If true return also template snapshots. If not specified template snapshots are not returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('include_active', include_active, bool), ('include_template', include_template, bool), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if include_active is not None: include_active = Writer.render_boolean(include_active) query['include_active'] = include_active if include_template is not None: include_template = Writer.render_boolean(include_template) query['include_template'] = include_template if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def snapshot_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return DiskSnapshotService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.snapshot_service(path) return self.snapshot_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DiskSnapshotsService:%s' % self._path
Manages the collection of disk snapshots available in an storage domain.
View Source
def __init__(self, connection, path): super(DiskSnapshotsService, self).__init__(connection, path) self._snapshot_service = None
Creates a new service that will use the given connection and path.
#
def
list(
self,
follow=None,
include_active=None,
include_template=None,
max=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, follow=None, include_active=None, include_template=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disk snapshots of the storage domain. The order of the returned list of disk snapshots isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of snapshots to return. If not specified all the snapshots are returned. `include_active`:: If true return also active snapshots. If not specified active snapshots are not returned. `include_template`:: If true return also template snapshots. If not specified template snapshots are not returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('include_active', include_active, bool), ('include_template', include_template, bool), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if include_active is not None: include_active = Writer.render_boolean(include_active) query['include_active'] = include_active if include_template is not None: include_template = Writer.render_boolean(include_template) query['include_template'] = include_template if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of disk snapshots of the storage domain. The order of the returned list of disk snapshots isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of snapshots to return. If not specified all the snapshots are returned.
include_active:: If true return also active snapshots. If not specified active snapshots are not returned.
include_template:: If true return also template snapshots. If not specified template snapshots are not returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def snapshot_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return DiskSnapshotService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.snapshot_service(path) return self.snapshot_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DisksService(Service): """ Manages the collection of disks available in the system. """ def __init__(self, connection, path): super(DisksService, self).__init__(connection, path) self._disk_service = None def add( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Adds a new floating disk. There are three types of disks that can be added - disk image, direct LUN and https://wiki.openstack.org/wiki/Cinder[Cinder] disk. *Adding a new image disk:* When creating a new floating image <<types/disk,Disk>>, the API requires the `storage_domain`, `provisioned_size` and `format` attributes. Note that block storage domains (i.e., storage domains with the <<types/storage_type, storage type>> of iSCSI or FCP) don't support the combination of the raw `format` with `sparse=true`, so `sparse=false` must be stated explicitly. To create a new floating image disk with specified `provisioned_size`, `format` and `name` on a storage domain with an id `123`, send a request as follows: [source] ---- POST /ovirt-engine/api/disks ---- With a request body as follows: [source,xml] ---- <disk> <storage_domains> <storage_domain id="123"/> </storage_domains> <name>mydisk</name> <provisioned_size>1048576</provisioned_size> <format>cow</format> </disk> ---- *Adding a new direct LUN disk:* When adding a new floating direct LUN via the API, there are two flavors that can be used: . With a `host` element - in this case, the host is used for sanity checks (e.g., that the LUN is visible) and to retrieve basic information about the LUN (e.g., size and serial). . Without a `host` element - in this case, the operation is a database-only operation, and the storage is never accessed. To create a new floating direct LUN disk with a `host` element with an id `123`, specified `alias`, `type` and `logical_unit` with an id `456` (that has the attributes `address`, `port` and `target`), send a request as follows: [source] ---- POST /ovirt-engine/api/disks ---- With a request body as follows: [source,xml] ---- <disk> <alias>mylun</alias> <lun_storage> <host id="123"/> <type>iscsi</type> <logical_units> <logical_unit id="456"> <address>10.35.10.20</address> <port>3260</port> <target>iqn.2017-01.com.myhost:444</target> </logical_unit> </logical_units> </lun_storage> </disk> ---- To create a new floating direct LUN disk without using a host, remove the `host` element. *Adding a new Cinder disk:* To create a new floating Cinder disk, send a request as follows: [source] ---- POST /ovirt-engine/api/disks ---- With a request body as follows: [source,xml] ---- <disk> <openstack_volume_type> <name>myceph</name> </openstack_volume_type> <storage_domains> <storage_domain> <name>cinderDomain</name> </storage_domain> </storage_domains> <provisioned_size>1073741824</provisioned_size> <interface>virtio</interface> <format>raw</format> </disk> ---- *Adding a floating disks in order to upload disk snapshots:* Since version 4.2 of the engine it is possible to upload disks with snapshots. This request should be used to create the base image of the images chain (The consecutive disk snapshots (images), should be created using `disk-attachments` element when creating a snapshot). The disk has to be created with the same disk identifier and image identifier of the uploaded image. I.e. the identifiers should be saved as part of the backup process. The image identifier can be also fetched using the `qemu-img info` command. For example, if the disk image is stored into a file named `b7a4c6c5-443b-47c5-967f-6abc79675e8b/myimage.img`: [source,shell] ---- $ qemu-img info b7a4c6c5-443b-47c5-967f-6abc79675e8b/myimage.img image: b548366b-fb51-4b41-97be-733c887fe305 file format: qcow2 virtual size: 1.0G (1073741824 bytes) disk size: 196K cluster_size: 65536 backing file: ad58716a-1fe9-481f-815e-664de1df04eb backing file format: raw ---- To create a disk with with the disk identifier and image identifier obtained with the `qemu-img info` command shown above, send a request like this: [source] ---- POST /ovirt-engine/api/disks ---- With a request body as follows: [source,xml] ---- <disk id="b7a4c6c5-443b-47c5-967f-6abc79675e8b"> <image_id>b548366b-fb51-4b41-97be-733c887fe305</image_id> <storage_domains> <storage_domain id="123"/> </storage_domains> <name>mydisk</name> <provisioned_size>1048576</provisioned_size> <format>cow</format> </disk> ---- This method supports the following parameters: `disk`:: The disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait) def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Get list of disks. [source] ---- GET /ovirt-engine/api/disks ---- You will get a XML response which will look like this one: [source,xml] ---- <disks> <disk id="123"> <actions>...</actions> <name>MyDisk</name> <description>MyDisk description</description> <link href="/ovirt-engine/api/disks/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/disks/123/statistics" rel="statistics"/> <actual_size>5345845248</actual_size> <alias>MyDisk alias</alias> ... <status>ok</status> <storage_type>image</storage_type> <wipe_after_delete>false</wipe_after_delete> <disk_profile id="123"/> <quota id="123"/> <storage_domains>...</storage_domains> </disk> ... </disks> ---- The order of the returned list of disks is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `search`:: A query string used to restrict the returned disks. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def add_lun( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Add a new lun disk to the storage domain. This method supports the following parameters: `disk`:: The disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait) def add_on_storage_domain( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Add a new disk to the storage domain with the specified size allocating space from the storage domain. This method supports the following parameters: `disk`:: The disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait) def disk_service(self, id): """ Reference to a service managing a specific disk. """ Service._check_types([ ('id', id, str), ]) return DiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DisksService:%s' % self._path
Manages the collection of disks available in the system.
View Source
def __init__(self, connection, path): super(DisksService, self).__init__(connection, path) self._disk_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Adds a new floating disk. There are three types of disks that can be added - disk image, direct LUN and https://wiki.openstack.org/wiki/Cinder[Cinder] disk. *Adding a new image disk:* When creating a new floating image <<types/disk,Disk>>, the API requires the `storage_domain`, `provisioned_size` and `format` attributes. Note that block storage domains (i.e., storage domains with the <<types/storage_type, storage type>> of iSCSI or FCP) don't support the combination of the raw `format` with `sparse=true`, so `sparse=false` must be stated explicitly. To create a new floating image disk with specified `provisioned_size`, `format` and `name` on a storage domain with an id `123`, send a request as follows: [source] ---- POST /ovirt-engine/api/disks ---- With a request body as follows: [source,xml] ---- <disk> <storage_domains> <storage_domain id="123"/> </storage_domains> <name>mydisk</name> <provisioned_size>1048576</provisioned_size> <format>cow</format> </disk> ---- *Adding a new direct LUN disk:* When adding a new floating direct LUN via the API, there are two flavors that can be used: . With a `host` element - in this case, the host is used for sanity checks (e.g., that the LUN is visible) and to retrieve basic information about the LUN (e.g., size and serial). . Without a `host` element - in this case, the operation is a database-only operation, and the storage is never accessed. To create a new floating direct LUN disk with a `host` element with an id `123`, specified `alias`, `type` and `logical_unit` with an id `456` (that has the attributes `address`, `port` and `target`), send a request as follows: [source] ---- POST /ovirt-engine/api/disks ---- With a request body as follows: [source,xml] ---- <disk> <alias>mylun</alias> <lun_storage> <host id="123"/> <type>iscsi</type> <logical_units> <logical_unit id="456"> <address>10.35.10.20</address> <port>3260</port> <target>iqn.2017-01.com.myhost:444</target> </logical_unit> </logical_units> </lun_storage> </disk> ---- To create a new floating direct LUN disk without using a host, remove the `host` element. *Adding a new Cinder disk:* To create a new floating Cinder disk, send a request as follows: [source] ---- POST /ovirt-engine/api/disks ---- With a request body as follows: [source,xml] ---- <disk> <openstack_volume_type> <name>myceph</name> </openstack_volume_type> <storage_domains> <storage_domain> <name>cinderDomain</name> </storage_domain> </storage_domains> <provisioned_size>1073741824</provisioned_size> <interface>virtio</interface> <format>raw</format> </disk> ---- *Adding a floating disks in order to upload disk snapshots:* Since version 4.2 of the engine it is possible to upload disks with snapshots. This request should be used to create the base image of the images chain (The consecutive disk snapshots (images), should be created using `disk-attachments` element when creating a snapshot). The disk has to be created with the same disk identifier and image identifier of the uploaded image. I.e. the identifiers should be saved as part of the backup process. The image identifier can be also fetched using the `qemu-img info` command. For example, if the disk image is stored into a file named `b7a4c6c5-443b-47c5-967f-6abc79675e8b/myimage.img`: [source,shell] ---- $ qemu-img info b7a4c6c5-443b-47c5-967f-6abc79675e8b/myimage.img image: b548366b-fb51-4b41-97be-733c887fe305 file format: qcow2 virtual size: 1.0G (1073741824 bytes) disk size: 196K cluster_size: 65536 backing file: ad58716a-1fe9-481f-815e-664de1df04eb backing file format: raw ---- To create a disk with with the disk identifier and image identifier obtained with the `qemu-img info` command shown above, send a request like this: [source] ---- POST /ovirt-engine/api/disks ---- With a request body as follows: [source,xml] ---- <disk id="b7a4c6c5-443b-47c5-967f-6abc79675e8b"> <image_id>b548366b-fb51-4b41-97be-733c887fe305</image_id> <storage_domains> <storage_domain id="123"/> </storage_domains> <name>mydisk</name> <provisioned_size>1048576</provisioned_size> <format>cow</format> </disk> ---- This method supports the following parameters: `disk`:: The disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait)
Adds a new floating disk.
There are three types of disks that can be added - disk image, direct LUN and
https://wiki.openstack.org/wiki/Cinder[Cinder] disk.
Adding a new image disk:
When creating a new floating image <storage_domain, provisioned_size
and format attributes.
Note that block storage domains (i.e., storage domains with the <format with sparse=true, so sparse=false must be stated
explicitly.
To create a new floating image disk with specified provisioned_size, format and name on a storage domain
with an id 123, send a request as follows:
[source]
POST /ovirt-engine/api/disks
With a request body as follows:
[source,xml]
Adding a new direct LUN disk:
When adding a new floating direct LUN via the API, there are two flavors that can be used:
. With a host element - in this case, the host is used for sanity checks (e.g., that the LUN is visible) and
to retrieve basic information about the LUN (e.g., size and serial).
. Without a host element - in this case, the operation is a database-only operation, and the storage is never
accessed.
To create a new floating direct LUN disk with a host element with an id 123, specified alias, type and
logical_unit with an id 456 (that has the attributes address, port and target),
send a request as follows:
[source]
POST /ovirt-engine/api/disks
With a request body as follows:
[source,xml]
To create a new floating direct LUN disk without using a host, remove the host element.
Adding a new Cinder disk:
To create a new floating Cinder disk, send a request as follows:
[source]
POST /ovirt-engine/api/disks
With a request body as follows:
[source,xml]
Adding a floating disks in order to upload disk snapshots:
Since version 4.2 of the engine it is possible to upload disks with
snapshots. This request should be used to create the base image of the
images chain (The consecutive disk snapshots (images), should be created
using disk-attachments element when creating a snapshot).
The disk has to be created with the same disk identifier and image identifier
of the uploaded image. I.e. the identifiers should be saved as part of the
backup process. The image identifier can be also fetched using the
qemu-img info command. For example, if the disk image is stored into
a file named b7a4c6c5-443b-47c5-967f-6abc79675e8b/myimage.img:
[source,shell]
$ qemu-img info b7a4c6c5-443b-47c5-967f-6abc79675e8b/myimage.img image: b548366b-fb51-4b41-97be-733c887fe305 file format: qcow2 virtual size: 1.0G (1073741824 bytes) disk size: 196K cluster_size: 65536 backing file: ad58716a-1fe9-481f-815e-664de1df04eb
backing file format: raw
To create a disk with with the disk identifier and image identifier obtained
with the qemu-img info command shown above, send a request like this:
[source]
POST /ovirt-engine/api/disks
With a request body as follows:
[source,xml]
This method supports the following parameters:
disk:: The disk.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
list(
self,
case_sensitive=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Get list of disks. [source] ---- GET /ovirt-engine/api/disks ---- You will get a XML response which will look like this one: [source,xml] ---- <disks> <disk id="123"> <actions>...</actions> <name>MyDisk</name> <description>MyDisk description</description> <link href="/ovirt-engine/api/disks/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/disks/123/statistics" rel="statistics"/> <actual_size>5345845248</actual_size> <alias>MyDisk alias</alias> ... <status>ok</status> <storage_type>image</storage_type> <wipe_after_delete>false</wipe_after_delete> <disk_profile id="123"/> <quota id="123"/> <storage_domains>...</storage_domains> </disk> ... </disks> ---- The order of the returned list of disks is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `search`:: A query string used to restrict the returned disks. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get list of disks.
[source]
GET /ovirt-engine/api/disks
You will get a XML response which will look like this one:
[source,xml]
The order of the returned list of disks is guaranteed only if the sortby clause is included in the
search parameter.
This method supports the following parameters:
max:: Sets the maximum number of disks to return. If not specified all the disks are returned.
search:: A query string used to restrict the returned disks.
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_lun( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Add a new lun disk to the storage domain. This method supports the following parameters: `disk`:: The disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait)
Add a new lun disk to the storage domain.
This method supports the following parameters:
disk:: The disk.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_on_storage_domain( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Add a new disk to the storage domain with the specified size allocating space from the storage domain. This method supports the following parameters: `disk`:: The disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait)
Add a new disk to the storage domain with the specified size allocating space from the storage domain.
This method supports the following parameters:
disk:: The disk.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disk_service(self, id): """ Reference to a service managing a specific disk. """ Service._check_types([ ('id', id, str), ]) return DiskService(self._connection, '%s/%s' % (self._path, id))
Reference to a service managing a specific disk.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DomainService(Service): """ A service to view details of an authentication domain in the system. """ def __init__(self, connection, path): super(DomainService, self).__init__(connection, path) self._groups_service = None self._users_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the authentication domain information. Usage: .... GET /ovirt-engine/api/domains/5678 .... Will return the domain information: [source,xml] ---- <domain href="/ovirt-engine/api/domains/5678" id="5678"> <name>internal-authz</name> <link href="/ovirt-engine/api/domains/5678/users" rel="users"/> <link href="/ovirt-engine/api/domains/5678/groups" rel="groups"/> <link href="/ovirt-engine/api/domains/5678/users?search={query}" rel="users/search"/> <link href="/ovirt-engine/api/domains/5678/groups?search={query}" rel="groups/search"/> </domain> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def groups_service(self): """ Reference to a service to manage domain groups. """ return DomainGroupsService(self._connection, '%s/groups' % self._path) def users_service(self): """ Reference to a service to manage domain users. """ return DomainUsersService(self._connection, '%s/users' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'groups': return self.groups_service() if path.startswith('groups/'): return self.groups_service().service(path[7:]) if path == 'users': return self.users_service() if path.startswith('users/'): return self.users_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DomainService:%s' % self._path
A service to view details of an authentication domain in the system.
View Source
def __init__(self, connection, path): super(DomainService, self).__init__(connection, path) self._groups_service = None self._users_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the authentication domain information. Usage: .... GET /ovirt-engine/api/domains/5678 .... Will return the domain information: [source,xml] ---- <domain href="/ovirt-engine/api/domains/5678" id="5678"> <name>internal-authz</name> <link href="/ovirt-engine/api/domains/5678/users" rel="users"/> <link href="/ovirt-engine/api/domains/5678/groups" rel="groups"/> <link href="/ovirt-engine/api/domains/5678/users?search={query}" rel="users/search"/> <link href="/ovirt-engine/api/domains/5678/groups?search={query}" rel="groups/search"/> </domain> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets the authentication domain information. Usage: .... GET /ovirt-engine/api/domains/5678 .... Will return the domain information:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def groups_service(self): """ Reference to a service to manage domain groups. """ return DomainGroupsService(self._connection, '%s/groups' % self._path)
Reference to a service to manage domain groups.
View Source
def users_service(self): """ Reference to a service to manage domain users. """ return DomainUsersService(self._connection, '%s/users' % self._path)
Reference to a service to manage domain users.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'groups': return self.groups_service() if path.startswith('groups/'): return self.groups_service().service(path[7:]) if path == 'users': return self.users_service() if path.startswith('users/'): return self.users_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DomainGroupService(Service): """ """ def __init__(self, connection, path): super(DomainGroupService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DomainGroupService:%s' % self._path
View Source
def __init__(self, connection, path): super(DomainGroupService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DomainGroupsService(Service): """ """ def __init__(self, connection, path): super(DomainGroupsService, self).__init__(connection, path) self._group_service = None def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of groups. The order of the returned list of groups isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of groups to return. If not specified all the groups are returned. `search`:: A query string used to restrict the returned groups. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def group_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return DomainGroupService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.group_service(path) return self.group_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DomainGroupsService:%s' % self._path
View Source
def __init__(self, connection, path): super(DomainGroupsService, self).__init__(connection, path) self._group_service = None
Creates a new service that will use the given connection and path.
#
def
list(
self,
case_sensitive=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of groups. The order of the returned list of groups isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of groups to return. If not specified all the groups are returned. `search`:: A query string used to restrict the returned groups. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of groups. The order of the returned list of groups isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of groups to return. If not specified all the groups are returned.
search:: A query string used to restrict the returned groups.
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def group_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return DomainGroupService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.group_service(path) return self.group_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DomainUserService(Service): """ A service to view a domain user in the system. """ def __init__(self, connection, path): super(DomainUserService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the domain user information. Usage: .... GET /ovirt-engine/api/domains/5678/users/1234 .... Will return the domain user information: [source,xml] ---- <user href="/ovirt-engine/api/users/1234" id="1234"> <name>admin</name> <namespace>*</namespace> <principal>admin</principal> <user_name>admin@internal-authz</user_name> <domain href="/ovirt-engine/api/domains/5678" id="5678"> <name>internal-authz</name> </domain> <groups/> </user> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DomainUserService:%s' % self._path
A service to view a domain user in the system.
View Source
def __init__(self, connection, path): super(DomainUserService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the domain user information. Usage: .... GET /ovirt-engine/api/domains/5678/users/1234 .... Will return the domain user information: [source,xml] ---- <user href="/ovirt-engine/api/users/1234" id="1234"> <name>admin</name> <namespace>*</namespace> <principal>admin</principal> <user_name>admin@internal-authz</user_name> <domain href="/ovirt-engine/api/domains/5678" id="5678"> <name>internal-authz</name> </domain> <groups/> </user> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets the domain user information. Usage: .... GET /ovirt-engine/api/domains/5678/users/1234 .... Will return the domain user information:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DomainUserGroupsService(Service): """ A service that shows a user's group membership in the AAA extension. """ def __init__(self, connection, path): super(DomainUserGroupsService, self).__init__(connection, path) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of groups that the user is a member of. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DomainUserGroupsService:%s' % self._path
A service that shows a user's group membership in the AAA extension.
View Source
def __init__(self, connection, path): super(DomainUserGroupsService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of groups that the user is a member of. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of groups that the user is a member of.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DomainUsersService(Service): """ A service to list all domain users in the system. """ def __init__(self, connection, path): super(DomainUsersService, self).__init__(connection, path) self._user_service = None def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ List all the users in the domain. Usage: .... GET /ovirt-engine/api/domains/5678/users .... Will return the list of users in the domain: [source,xml] ---- <users> <user href="/ovirt-engine/api/domains/5678/users/1234" id="1234"> <name>admin</name> <namespace>*</namespace> <principal>admin</principal> <user_name>admin@internal-authz</user_name> <domain href="/ovirt-engine/api/domains/5678" id="5678"> <name>internal-authz</name> </domain> <groups/> </user> </users> ---- The order of the returned list of users isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of users to return. If not specified all the users are returned. `search`:: A query string used to restrict the returned users. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def user_service(self, id): """ Reference to a service to view details of a domain user. """ Service._check_types([ ('id', id, str), ]) return DomainUserService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.user_service(path) return self.user_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DomainUsersService:%s' % self._path
A service to list all domain users in the system.
View Source
def __init__(self, connection, path): super(DomainUsersService, self).__init__(connection, path) self._user_service = None
Creates a new service that will use the given connection and path.
#
def
list(
self,
case_sensitive=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ List all the users in the domain. Usage: .... GET /ovirt-engine/api/domains/5678/users .... Will return the list of users in the domain: [source,xml] ---- <users> <user href="/ovirt-engine/api/domains/5678/users/1234" id="1234"> <name>admin</name> <namespace>*</namespace> <principal>admin</principal> <user_name>admin@internal-authz</user_name> <domain href="/ovirt-engine/api/domains/5678" id="5678"> <name>internal-authz</name> </domain> <groups/> </user> </users> ---- The order of the returned list of users isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of users to return. If not specified all the users are returned. `search`:: A query string used to restrict the returned users. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List all the users in the domain. Usage: .... GET /ovirt-engine/api/domains/5678/users .... Will return the list of users in the domain:
[source,xml]
The order of the returned list of users isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of users to return. If not specified all the users are returned.
search:: A query string used to restrict the returned users.
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def user_service(self, id): """ Reference to a service to view details of a domain user. """ Service._check_types([ ('id', id, str), ]) return DomainUserService(self._connection, '%s/%s' % (self._path, id))
Reference to a service to view details of a domain user.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.user_service(path) return self.user_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DomainsService(Service): """ A service to list all authentication domains in the system. """ def __init__(self, connection, path): super(DomainsService, self).__init__(connection, path) self._domain_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all the authentication domains in the system. Usage: .... GET /ovirt-engine/api/domains .... Will return the list of domains: [source,xml] ---- <domains> <domain href="/ovirt-engine/api/domains/5678" id="5678"> <name>internal-authz</name> <link href="/ovirt-engine/api/domains/5678/users" rel="users"/> <link href="/ovirt-engine/api/domains/5678/groups" rel="groups"/> <link href="/ovirt-engine/api/domains/5678/users?search={query}" rel="users/search"/> <link href="/ovirt-engine/api/domains/5678/groups?search={query}" rel="groups/search"/> </domain> </domains> ---- The order of the returned list of domains isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of domains to return. If not specified all the domains are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def domain_service(self, id): """ Reference to a service to view details of a domain. """ Service._check_types([ ('id', id, str), ]) return DomainService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.domain_service(path) return self.domain_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'DomainsService:%s' % self._path
A service to list all authentication domains in the system.
View Source
def __init__(self, connection, path): super(DomainsService, self).__init__(connection, path) self._domain_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all the authentication domains in the system. Usage: .... GET /ovirt-engine/api/domains .... Will return the list of domains: [source,xml] ---- <domains> <domain href="/ovirt-engine/api/domains/5678" id="5678"> <name>internal-authz</name> <link href="/ovirt-engine/api/domains/5678/users" rel="users"/> <link href="/ovirt-engine/api/domains/5678/groups" rel="groups"/> <link href="/ovirt-engine/api/domains/5678/users?search={query}" rel="users/search"/> <link href="/ovirt-engine/api/domains/5678/groups?search={query}" rel="groups/search"/> </domain> </domains> ---- The order of the returned list of domains isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of domains to return. If not specified all the domains are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List all the authentication domains in the system. Usage: .... GET /ovirt-engine/api/domains .... Will return the list of domains:
[source,xml]
The order of the returned list of domains isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of domains to return. If not specified all the domains are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def domain_service(self, id): """ Reference to a service to view details of a domain. """ Service._check_types([ ('id', id, str), ]) return DomainService(self._connection, '%s/%s' % (self._path, id))
Reference to a service to view details of a domain.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.domain_service(path) return self.domain_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class EventService(Service): """ A service to manage an event in the system. """ def __init__(self, connection, path): super(EventService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get an event. An example of getting an event: [source] ---- GET /ovirt-engine/api/events/123 ---- [source,xml] ---- <event href="/ovirt-engine/api/events/123" id="123"> <description>Host example.com was added by admin@internal-authz.</description> <code>42</code> <correlation_id>135</correlation_id> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-12-11T11:13:44.654+02:00</time> <cluster href="/ovirt-engine/api/clusters/456" id="456"/> <host href="/ovirt-engine/api/hosts/789" id="789"/> <user href="/ovirt-engine/api/users/987" id="987"/> </event> ---- Note that the number of fields changes according to the information that resides on the event. For example, for storage domain related events you will get the storage domain reference, as well as the reference for the data center this storage domain resides in. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes an event from internal audit log. An event can be removed by sending following request [source] ---- DELETE /ovirt-engine/api/events/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'EventService:%s' % self._path
A service to manage an event in the system.
View Source
def __init__(self, connection, path): super(EventService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get an event. An example of getting an event: [source] ---- GET /ovirt-engine/api/events/123 ---- [source,xml] ---- <event href="/ovirt-engine/api/events/123" id="123"> <description>Host example.com was added by admin@internal-authz.</description> <code>42</code> <correlation_id>135</correlation_id> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-12-11T11:13:44.654+02:00</time> <cluster href="/ovirt-engine/api/clusters/456" id="456"/> <host href="/ovirt-engine/api/hosts/789" id="789"/> <user href="/ovirt-engine/api/users/987" id="987"/> </event> ---- Note that the number of fields changes according to the information that resides on the event. For example, for storage domain related events you will get the storage domain reference, as well as the reference for the data center this storage domain resides in. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get an event. An example of getting an event:
[source]
GET /ovirt-engine/api/events/123
[source,xml]
42
Note that the number of fields changes according to the information that resides on the event. For example, for storage domain related events you will get the storage domain reference, as well as the reference for the data center this storage domain resides in.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes an event from internal audit log. An event can be removed by sending following request [source] ---- DELETE /ovirt-engine/api/events/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes an event from internal audit log. An event can be removed by sending following request
[source]
DELETE /ovirt-engine/api/events/123
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class EventSubscriptionService(Service): """ A service to manage a specific event-subscription in the system. """ def __init__(self, connection, path): super(EventSubscriptionService, self).__init__(connection, path) def get( self, headers=None, query=None, wait=True, **kwargs ): """ Gets the information about the event-subscription. For example to retrieve the information about the subscription of user '123' to the event 'vm_console_detected': .... GET /ovirt-engine/api/users/123/vm_console_detected .... [source,xml] ---- <event-subscription href="/ovirt-engine/api/users/123/event-subscriptions/vm_console_detected"> <event>vm_console_detected</event> <notification_method>smtp</notification_method> <user href="/ovirt-engine/api/users/123" id="123"/> <address>a@b.com</address> </event-subscription> ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the event-subscription from the system. For example to remove user 123's subscription to `vm_console_detected` event: .... DELETE /ovirt-engine/api/users/123/vm_console_detected .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'EventSubscriptionService:%s' % self._path
A service to manage a specific event-subscription in the system.
View Source
def __init__(self, connection, path): super(EventSubscriptionService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, headers=None, query=None, wait=True, **kwargs ): """ Gets the information about the event-subscription. For example to retrieve the information about the subscription of user '123' to the event 'vm_console_detected': .... GET /ovirt-engine/api/users/123/vm_console_detected .... [source,xml] ---- <event-subscription href="/ovirt-engine/api/users/123/event-subscriptions/vm_console_detected"> <event>vm_console_detected</event> <notification_method>smtp</notification_method> <user href="/ovirt-engine/api/users/123" id="123"/> <address>a@b.com</address> </event-subscription> ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets the information about the event-subscription. For example to retrieve the information about the subscription of user '123' to the event 'vm_console_detected': .... GET /ovirt-engine/api/users/123/vm_console_detected ....
[source,xml]
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the event-subscription from the system. For example to remove user 123's subscription to `vm_console_detected` event: .... DELETE /ovirt-engine/api/users/123/vm_console_detected .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the event-subscription from the system.
For example to remove user 123's subscription to vm_console_detected event:
....
DELETE /ovirt-engine/api/users/123/vm_console_detected
....
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class EventSubscriptionsService(Service): """ Represents a service to manage collection of event-subscription of a user. """ def __init__(self, connection, path): super(EventSubscriptionsService, self).__init__(connection, path) self._event_subscription_service = None def add( self, event_subscription, headers=None, query=None, wait=True, **kwargs ): """ Add a new event-subscription to the system. An event-subscription is always added in the context of a user. For example, to add new event-subscription for `host_high_cpu_use` for user `123`, and have the notification sent to the e-mail address: `a@b.com`, send a request like this: .... POST /ovirt-engine/api/users/123/eventsubscriptions .... With a request body like this: [source,xml] ---- <event_subscription> <event>host_high_cpu_use</event> <address>a@b.com</address> </event_subscription> ---- The event name will become the ID of the new event-subscription entity: GET .../api/users/123/eventsubscriptions/host_high_cpu_use Note that no user id is provided in the request body. This is because the user-id (in this case 123) is already known to the API from the context. Note also that event-subscription entity contains notification-method field, but it is not provided either in the request body. This is because currently it's always set to SMTP as SNMP notifications are still unsupported by the API layer. This method supports the following parameters: `event_subscription`:: The added event-subscription. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('event_subscription', event_subscription, types.EventSubscription), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(event_subscription, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the event-subscriptions for the provided user. For example to list event-subscriptions for user `123`: .... GET /ovirt-engine/api/users/123/event-subscriptions .... [source,xml] ---- <event-subscriptions> <event-subscription href="/ovirt-engine/api/users/123/event-subscriptions/host_install_failed"> <event>host_install_failed</event> <notification_method>smtp</notification_method> <user href="/ovirt-engine/api/users/123" id="123"/> <address>a@b.com</address> </event-subscription> <event-subscription href="/ovirt-engine/api/users/123/event-subscriptions/vm_paused"> <event>vm_paused</event> <notification_method>smtp</notification_method> <user href="/ovirt-engine/api/users/123" id="123"/> <address>a@b.com</address> </event-subscription> </event-subscriptions> ---- This method supports the following parameters: `max`:: Sets the maximum number of event-subscriptions to return. If not specified all the event-subscriptions are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def event_subscription_service(self, id): """ Reference to the service that manages a specific event-subscription. """ Service._check_types([ ('id', id, str), ]) return EventSubscriptionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.event_subscription_service(path) return self.event_subscription_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'EventSubscriptionsService:%s' % self._path
Represents a service to manage collection of event-subscription of a user.
View Source
def __init__(self, connection, path): super(EventSubscriptionsService, self).__init__(connection, path) self._event_subscription_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, event_subscription, headers=None, query=None, wait=True, **kwargs ): """ Add a new event-subscription to the system. An event-subscription is always added in the context of a user. For example, to add new event-subscription for `host_high_cpu_use` for user `123`, and have the notification sent to the e-mail address: `a@b.com`, send a request like this: .... POST /ovirt-engine/api/users/123/eventsubscriptions .... With a request body like this: [source,xml] ---- <event_subscription> <event>host_high_cpu_use</event> <address>a@b.com</address> </event_subscription> ---- The event name will become the ID of the new event-subscription entity: GET .../api/users/123/eventsubscriptions/host_high_cpu_use Note that no user id is provided in the request body. This is because the user-id (in this case 123) is already known to the API from the context. Note also that event-subscription entity contains notification-method field, but it is not provided either in the request body. This is because currently it's always set to SMTP as SNMP notifications are still unsupported by the API layer. This method supports the following parameters: `event_subscription`:: The added event-subscription. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('event_subscription', event_subscription, types.EventSubscription), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(event_subscription, headers, query, wait)
Add a new event-subscription to the system.
An event-subscription is always added in the context of a user. For example, to add new
event-subscription for host_high_cpu_use for user 123, and have the notification
sent to the e-mail address: a@b.com, send a request like this:
....
POST /ovirt-engine/api/users/123/eventsubscriptions
....
With a request body like this:
[source,xml]
The event name will become the ID of the new event-subscription entity: GET .../api/users/123/eventsubscriptions/host_high_cpu_use Note that no user id is provided in the request body. This is because the user-id (in this case 123) is already known to the API from the context. Note also that event-subscription entity contains notification-method field, but it is not provided either in the request body. This is because currently it's always set to SMTP as SNMP notifications are still unsupported by the API layer.
This method supports the following parameters:
event_subscription:: The added event-subscription.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the event-subscriptions for the provided user. For example to list event-subscriptions for user `123`: .... GET /ovirt-engine/api/users/123/event-subscriptions .... [source,xml] ---- <event-subscriptions> <event-subscription href="/ovirt-engine/api/users/123/event-subscriptions/host_install_failed"> <event>host_install_failed</event> <notification_method>smtp</notification_method> <user href="/ovirt-engine/api/users/123" id="123"/> <address>a@b.com</address> </event-subscription> <event-subscription href="/ovirt-engine/api/users/123/event-subscriptions/vm_paused"> <event>vm_paused</event> <notification_method>smtp</notification_method> <user href="/ovirt-engine/api/users/123" id="123"/> <address>a@b.com</address> </event-subscription> </event-subscriptions> ---- This method supports the following parameters: `max`:: Sets the maximum number of event-subscriptions to return. If not specified all the event-subscriptions are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List the event-subscriptions for the provided user.
For example to list event-subscriptions for user 123:
....
GET /ovirt-engine/api/users/123/event-subscriptions
....
[source,xml]
This method supports the following parameters:
max:: Sets the maximum number of event-subscriptions to return.
If not specified all the event-subscriptions are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def event_subscription_service(self, id): """ Reference to the service that manages a specific event-subscription. """ Service._check_types([ ('id', id, str), ]) return EventSubscriptionService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages a specific event-subscription.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.event_subscription_service(path) return self.event_subscription_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class EventsService(Service): """ A service to manage events in the system. """ def __init__(self, connection, path): super(EventsService, self).__init__(connection, path) self._event_service = None def add( self, event, headers=None, query=None, wait=True, **kwargs ): """ Adds an external event to the internal audit log. This is intended for integration with external systems that detect or produce events relevant for the administrator of the system. For example, an external monitoring tool may be able to detect that a file system is full inside the guest operating system of a virtual machine. This event can be added to the internal audit log sending a request like this: [source] ---- POST /ovirt-engine/api/events <event> <description>File system /home is full</description> <severity>alert</severity> <origin>mymonitor</origin> <custom_id>1467879754</custom_id> </event> ---- Events can also be linked to specific objects. For example, the above event could be linked to the specific virtual machine where it happened, using the `vm` link: [source] ---- POST /ovirt-engine/api/events <event> <description>File system /home is full</description> <severity>alert</severity> <origin>mymonitor</origin> <custom_id>1467879754</custom_id> <vm id="aae98225-5b73-490d-a252-899209af17e9"/> </event> ---- NOTE: When using links, like the `vm` in the previous example, only the `id` attribute is accepted. The `name` attribute, if provided, is simply ignored. """ # Check the types of the parameters: Service._check_types([ ('event', event, types.Event), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(event, headers, query, wait) def list( self, case_sensitive=None, follow=None, from_=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Get list of events. [source] ---- GET /ovirt-engine/api/events ---- To the above request we get following response: [source,xml] ---- <events> <event href="/ovirt-engine/api/events/2" id="2"> <description>User admin@internal-authz logged out.</description> <code>31</code> <correlation_id>1e892ea9</correlation_id> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-09-14T12:14:34.541+02:00</time> <user href="/ovirt-engine/api/users/57d91d48-00da-0137-0138-000000000244" id="57d91d48-00da-0137-0138-000000000244"/> </event> <event href="/ovirt-engine/api/events/1" id="1"> <description>User admin logged in.</description> <code>30</code> <correlation_id>1fbd81f4</correlation_id> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-09-14T11:54:35.229+02:00</time> <user href="/ovirt-engine/api/users/57d91d48-00da-0137-0138-000000000244" id="57d91d48-00da-0137-0138-000000000244"/> </event> </events> ---- The following events occur: * id="1" - The API logs in the admin user account. * id="2" - The API logs out of the admin user account. The order of the returned list of events is always garanteed. If the `sortby` clause is included in the `search` parameter, then the events will be ordered according to that clause. If the `sortby` clause isn't included, then the events will be sorted by the numeric value of the `id` attribute, starting with the highest value. This, combined with the `max` parameter, simplifies obtaining the most recent event: .... GET /ovirt-engine/api/events?max=1 .... This method supports the following parameters: `from_`:: Indicates the event index after which events should be returned. The indexes of events are strictly increasing, so when this parameter is used only the events with greater indexes will be returned. For example, the following request will return only the events with indexes greater than `123`: [source] ---- GET /ovirt-engine/api/events?from=123 ---- This parameter is optional, and if not specified then the first event returned will be most recently generated. `max`:: Sets the maximum number of events to return. If not specified all the events are returned. `search`:: The events service provides search queries similar to other resource services. We can search by providing specific severity. [source] ---- GET /ovirt-engine/api/events?search=severity%3Dnormal ---- To the above request we get a list of events which severity is equal to `normal`: [source,xml] ---- <events> <event href="/ovirt-engine/api/events/2" id="2"> <description>User admin@internal-authz logged out.</description> <code>31</code> <correlation_id>1fbd81f4</correlation_id> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-09-14T11:54:35.229+02:00</time> <user href="/ovirt-engine/api/users/57d91d48-00da-0137-0138-000000000244" id="57d91d48-00da-0137-0138-000000000244"/> </event> <event href="/ovirt-engine/api/events/1" id="1"> <description>Affinity Rules Enforcement Manager started.</description> <code>10780</code> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-09-14T11:52:18.861+02:00</time> </event> </events> ---- A virtualization environment generates a large amount of events after a period of time. However, the API only displays a default number of events for one search query. To display more than the default, the API separates results into pages with the page command in a search query. The following search query tells the API to paginate results using a page value in combination with the sortby clause: [source] ---- sortby time asc page 1 ---- Below example paginates event resources. The URL-encoded request is: [source] ---- GET /ovirt-engine/api/events?search=sortby%20time%20asc%20page%201 ---- Increase the page value to view the next page of results. [source] ---- GET /ovirt-engine/api/events?search=sortby%20time%20asc%20page%202 ---- `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('from_', from_, int), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if from_ is not None: from_ = Writer.render_integer(from_) query['from'] = from_ if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def undelete( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the un-delete should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'undelete', None, headers, query, wait) def event_service(self, id): """ Reference to the service that manages a specific event. """ Service._check_types([ ('id', id, str), ]) return EventService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.event_service(path) return self.event_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'EventsService:%s' % self._path
A service to manage events in the system.
View Source
def __init__(self, connection, path): super(EventsService, self).__init__(connection, path) self._event_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, event, headers=None, query=None, wait=True, **kwargs ): """ Adds an external event to the internal audit log. This is intended for integration with external systems that detect or produce events relevant for the administrator of the system. For example, an external monitoring tool may be able to detect that a file system is full inside the guest operating system of a virtual machine. This event can be added to the internal audit log sending a request like this: [source] ---- POST /ovirt-engine/api/events <event> <description>File system /home is full</description> <severity>alert</severity> <origin>mymonitor</origin> <custom_id>1467879754</custom_id> </event> ---- Events can also be linked to specific objects. For example, the above event could be linked to the specific virtual machine where it happened, using the `vm` link: [source] ---- POST /ovirt-engine/api/events <event> <description>File system /home is full</description> <severity>alert</severity> <origin>mymonitor</origin> <custom_id>1467879754</custom_id> <vm id="aae98225-5b73-490d-a252-899209af17e9"/> </event> ---- NOTE: When using links, like the `vm` in the previous example, only the `id` attribute is accepted. The `name` attribute, if provided, is simply ignored. """ # Check the types of the parameters: Service._check_types([ ('event', event, types.Event), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(event, headers, query, wait)
Adds an external event to the internal audit log. This is intended for integration with external systems that detect or produce events relevant for the administrator of the system. For example, an external monitoring tool may be able to detect that a file system is full inside the guest operating system of a virtual machine. This event can be added to the internal audit log sending a request like this:
[source]
POST /ovirt-engine/api/events
Events can also be linked to specific objects. For example, the above event could be linked to the specific
virtual machine where it happened, using the vm link:
[source]
POST /ovirt-engine/api/events
NOTE: When using links, like the vm in the previous example, only the id attribute is accepted. The name
attribute, if provided, is simply ignored.
#
def
list(
self,
case_sensitive=None,
follow=None,
from_=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, follow=None, from_=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Get list of events. [source] ---- GET /ovirt-engine/api/events ---- To the above request we get following response: [source,xml] ---- <events> <event href="/ovirt-engine/api/events/2" id="2"> <description>User admin@internal-authz logged out.</description> <code>31</code> <correlation_id>1e892ea9</correlation_id> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-09-14T12:14:34.541+02:00</time> <user href="/ovirt-engine/api/users/57d91d48-00da-0137-0138-000000000244" id="57d91d48-00da-0137-0138-000000000244"/> </event> <event href="/ovirt-engine/api/events/1" id="1"> <description>User admin logged in.</description> <code>30</code> <correlation_id>1fbd81f4</correlation_id> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-09-14T11:54:35.229+02:00</time> <user href="/ovirt-engine/api/users/57d91d48-00da-0137-0138-000000000244" id="57d91d48-00da-0137-0138-000000000244"/> </event> </events> ---- The following events occur: * id="1" - The API logs in the admin user account. * id="2" - The API logs out of the admin user account. The order of the returned list of events is always garanteed. If the `sortby` clause is included in the `search` parameter, then the events will be ordered according to that clause. If the `sortby` clause isn't included, then the events will be sorted by the numeric value of the `id` attribute, starting with the highest value. This, combined with the `max` parameter, simplifies obtaining the most recent event: .... GET /ovirt-engine/api/events?max=1 .... This method supports the following parameters: `from_`:: Indicates the event index after which events should be returned. The indexes of events are strictly increasing, so when this parameter is used only the events with greater indexes will be returned. For example, the following request will return only the events with indexes greater than `123`: [source] ---- GET /ovirt-engine/api/events?from=123 ---- This parameter is optional, and if not specified then the first event returned will be most recently generated. `max`:: Sets the maximum number of events to return. If not specified all the events are returned. `search`:: The events service provides search queries similar to other resource services. We can search by providing specific severity. [source] ---- GET /ovirt-engine/api/events?search=severity%3Dnormal ---- To the above request we get a list of events which severity is equal to `normal`: [source,xml] ---- <events> <event href="/ovirt-engine/api/events/2" id="2"> <description>User admin@internal-authz logged out.</description> <code>31</code> <correlation_id>1fbd81f4</correlation_id> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-09-14T11:54:35.229+02:00</time> <user href="/ovirt-engine/api/users/57d91d48-00da-0137-0138-000000000244" id="57d91d48-00da-0137-0138-000000000244"/> </event> <event href="/ovirt-engine/api/events/1" id="1"> <description>Affinity Rules Enforcement Manager started.</description> <code>10780</code> <custom_id>-1</custom_id> <flood_rate>30</flood_rate> <origin>oVirt</origin> <severity>normal</severity> <time>2016-09-14T11:52:18.861+02:00</time> </event> </events> ---- A virtualization environment generates a large amount of events after a period of time. However, the API only displays a default number of events for one search query. To display more than the default, the API separates results into pages with the page command in a search query. The following search query tells the API to paginate results using a page value in combination with the sortby clause: [source] ---- sortby time asc page 1 ---- Below example paginates event resources. The URL-encoded request is: [source] ---- GET /ovirt-engine/api/events?search=sortby%20time%20asc%20page%201 ---- Increase the page value to view the next page of results. [source] ---- GET /ovirt-engine/api/events?search=sortby%20time%20asc%20page%202 ---- `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('from_', from_, int), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if from_ is not None: from_ = Writer.render_integer(from_) query['from'] = from_ if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get list of events.
[source]
GET /ovirt-engine/api/events
To the above request we get following response:
[source,xml]
31
30
The following events occur:
- id="1" - The API logs in the admin user account.
- id="2" - The API logs out of the admin user account.
The order of the returned list of events is always garanteed. If the
sortbyclause is included in thesearchparameter, then the events will be ordered according to that clause. If thesortbyclause isn't included, then the events will be sorted by the numeric value of theidattribute, starting with the highest value. This, combined with themaxparameter, simplifies obtaining the most recent event: .... GET /ovirt-engine/api/events?max=1 ....
This method supports the following parameters:
from_:: Indicates the event index after which events should be returned. The indexes of events are
strictly increasing, so when this parameter is used only the events with greater indexes
will be returned. For example, the following request will return only the events
with indexes greater than 123:
[source]
GET /ovirt-engine/api/events?from=123
This parameter is optional, and if not specified then the first event returned will be most recently generated.
max:: Sets the maximum number of events to return. If not specified all the events are returned.
search:: The events service provides search queries similar to other resource services.
We can search by providing specific severity.
[source]
GET /ovirt-engine/api/events?search=severity%3Dnormal
To the above request we get a list of events which severity is equal to normal:
[source,xml]
31
10780
A virtualization environment generates a large amount of events after a period of time. However, the API only displays a default number of events for one search query. To display more than the default, the API separates results into pages with the page command in a search query. The following search query tells the API to paginate results using a page value in combination with the sortby clause:
[source]
sortby time asc page 1
Below example paginates event resources. The URL-encoded request is:
[source]
GET /ovirt-engine/api/events?search=sortby%20time%20asc%20page%201
Increase the page value to view the next page of results.
[source]
GET /ovirt-engine/api/events?search=sortby%20time%20asc%20page%202
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def undelete( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the un-delete should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'undelete', None, headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the un-delete should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def event_service(self, id): """ Reference to the service that manages a specific event. """ Service._check_types([ ('id', id, str), ]) return EventService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages a specific event.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.event_service(path) return self.event_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalComputeResourceService(Service): """ Manages a single external compute resource. Compute resource is a term of host external provider. The external provider also needs to know to where the provisioned host needs to register. The login details of the engine are saved as a compute resource in the external provider side. """ def __init__(self, connection, path): super(ExternalComputeResourceService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves external compute resource details. For example, to get the details of compute resource `234` of provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/computeresources/234 .... It will return a response like this: [source,xml] ---- <external_compute_resource href="/ovirt-engine/api/externalhostproviders/123/computeresources/234" id="234"> <name>hostname</name> <provider>oVirt</provider> <url>https://hostname/api</url> <user>admin@internal</user> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_compute_resource> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalComputeResourceService:%s' % self._path
Manages a single external compute resource. Compute resource is a term of host external provider. The external provider also needs to know to where the provisioned host needs to register. The login details of the engine are saved as a compute resource in the external provider side.
View Source
def __init__(self, connection, path): super(ExternalComputeResourceService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves external compute resource details. For example, to get the details of compute resource `234` of provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/computeresources/234 .... It will return a response like this: [source,xml] ---- <external_compute_resource href="/ovirt-engine/api/externalhostproviders/123/computeresources/234" id="234"> <name>hostname</name> <provider>oVirt</provider> <url>https://hostname/api</url> <user>admin@internal</user> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_compute_resource> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves external compute resource details.
For example, to get the details of compute resource 234 of provider 123, send a request like this:
....
GET /ovirt-engine/api/externalhostproviders/123/computeresources/234
....
It will return a response like this:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalComputeResourcesService(Service): """ Manages a collection of external compute resources. Compute resource is a term of host external provider. The external provider also needs to know to where the provisioned host needs to register. The login details of the engine is saved as a compute resource in the external provider side. """ def __init__(self, connection, path): super(ExternalComputeResourcesService, self).__init__(connection, path) self._resource_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a list of external compute resources. For example, to retrieve the compute resources of external host provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/computeresources .... It will return a response like this: [source,xml] ---- <external_compute_resources> <external_compute_resource href="/ovirt-engine/api/externalhostproviders/123/computeresources/234" id="234"> <name>hostname</name> <provider>oVirt</provider> <url>https://address/api</url> <user>admin@internal</user> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_compute_resource> ... </external_compute_resources> ---- The order of the returned list of compute resources isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of resources to return. If not specified all the resources are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def resource_service(self, id): """ This service manages compute resource instance """ Service._check_types([ ('id', id, str), ]) return ExternalComputeResourceService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.resource_service(path) return self.resource_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ExternalComputeResourcesService:%s' % self._path
Manages a collection of external compute resources. Compute resource is a term of host external provider. The external provider also needs to know to where the provisioned host needs to register. The login details of the engine is saved as a compute resource in the external provider side.
View Source
def __init__(self, connection, path): super(ExternalComputeResourcesService, self).__init__(connection, path) self._resource_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a list of external compute resources. For example, to retrieve the compute resources of external host provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/computeresources .... It will return a response like this: [source,xml] ---- <external_compute_resources> <external_compute_resource href="/ovirt-engine/api/externalhostproviders/123/computeresources/234" id="234"> <name>hostname</name> <provider>oVirt</provider> <url>https://address/api</url> <user>admin@internal</user> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_compute_resource> ... </external_compute_resources> ---- The order of the returned list of compute resources isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of resources to return. If not specified all the resources are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves a list of external compute resources.
For example, to retrieve the compute resources of external host provider 123, send a request like this:
....
GET /ovirt-engine/api/externalhostproviders/123/computeresources
....
It will return a response like this:
[source,xml]
The order of the returned list of compute resources isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of resources to return. If not specified all the resources are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def resource_service(self, id): """ This service manages compute resource instance """ Service._check_types([ ('id', id, str), ]) return ExternalComputeResourceService(self._connection, '%s/%s' % (self._path, id))
This service manages compute resource instance
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.resource_service(path) return self.resource_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalDiscoveredHostService(Service): """ This service manages a single discovered host. """ def __init__(self, connection, path): super(ExternalDiscoveredHostService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get discovered host info. Retrieves information about an host that is managed in external provider management system, such as Foreman. The information includes hostname, address, subnet, base image and more. For example, to get the details of host `234` from provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/discoveredhosts/234 .... The result will be like this: [source,xml] ---- <external_discovered_host href="/ovirt-engine/api/externalhostproviders/123/discoveredhosts/234" id="234"> <name>mac001a4ad04040</name> <ip>10.34.67.43</ip> <last_report>2017-04-24 11:05:41 UTC</last_report> <mac>00:1a:4a:d0:40:40</mac> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_discovered_host> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalDiscoveredHostService:%s' % self._path
This service manages a single discovered host.
View Source
def __init__(self, connection, path): super(ExternalDiscoveredHostService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get discovered host info. Retrieves information about an host that is managed in external provider management system, such as Foreman. The information includes hostname, address, subnet, base image and more. For example, to get the details of host `234` from provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/discoveredhosts/234 .... The result will be like this: [source,xml] ---- <external_discovered_host href="/ovirt-engine/api/externalhostproviders/123/discoveredhosts/234" id="234"> <name>mac001a4ad04040</name> <ip>10.34.67.43</ip> <last_report>2017-04-24 11:05:41 UTC</last_report> <mac>00:1a:4a:d0:40:40</mac> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_discovered_host> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get discovered host info.
Retrieves information about an host that is managed in external provider management system, such as Foreman. The
information includes hostname, address, subnet, base image and more.
For example, to get the details of host 234 from provider 123, send a request like this:
....
GET /ovirt-engine/api/externalhostproviders/123/discoveredhosts/234
....
The result will be like this:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalDiscoveredHostsService(Service): """ This service manages external discovered hosts. """ def __init__(self, connection, path): super(ExternalDiscoveredHostsService, self).__init__(connection, path) self._host_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Get list of discovered hosts' information. Discovered hosts are fetched from third-party providers such as Foreman. To list all discovered hosts for provider `123` send the following: [source] ---- GET /ovirt-engine/api/externalhostproviders/123/discoveredhost ---- [source,xml] ---- <external_discovered_hosts> <external_discovered_host href="/ovirt-engine/api/externalhostproviders/123/discoveredhosts/456" id="456"> <name>mac001a4ad04031</name> <ip>10.34.67.42</ip> <last_report>2017-04-24 11:05:41 UTC</last_report> <mac>00:1a:4a:d0:40:31</mac> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_discovered_host> <external_discovered_host href="/ovirt-engine/api/externalhostproviders/123/discoveredhosts/789" id="789"> <name>mac001a4ad04040</name> <ip>10.34.67.43</ip> <last_report>2017-04-24 11:05:41 UTC</last_report> <mac>00:1a:4a:d0:40:40</mac> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_discovered_host> ... </external_discovered_hosts> ---- The order of the returned list of hosts isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of hosts to return. If not specified all the hosts are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def host_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ExternalDiscoveredHostService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ExternalDiscoveredHostsService:%s' % self._path
This service manages external discovered hosts.
View Source
def __init__(self, connection, path): super(ExternalDiscoveredHostsService, self).__init__(connection, path) self._host_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Get list of discovered hosts' information. Discovered hosts are fetched from third-party providers such as Foreman. To list all discovered hosts for provider `123` send the following: [source] ---- GET /ovirt-engine/api/externalhostproviders/123/discoveredhost ---- [source,xml] ---- <external_discovered_hosts> <external_discovered_host href="/ovirt-engine/api/externalhostproviders/123/discoveredhosts/456" id="456"> <name>mac001a4ad04031</name> <ip>10.34.67.42</ip> <last_report>2017-04-24 11:05:41 UTC</last_report> <mac>00:1a:4a:d0:40:31</mac> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_discovered_host> <external_discovered_host href="/ovirt-engine/api/externalhostproviders/123/discoveredhosts/789" id="789"> <name>mac001a4ad04040</name> <ip>10.34.67.43</ip> <last_report>2017-04-24 11:05:41 UTC</last_report> <mac>00:1a:4a:d0:40:40</mac> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_discovered_host> ... </external_discovered_hosts> ---- The order of the returned list of hosts isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of hosts to return. If not specified all the hosts are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get list of discovered hosts' information.
Discovered hosts are fetched from third-party providers such as Foreman.
To list all discovered hosts for provider 123 send the following:
[source]
GET /ovirt-engine/api/externalhostproviders/123/discoveredhost
[source,xml]
The order of the returned list of hosts isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of hosts to return. If not specified all the hosts are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def host_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ExternalDiscoveredHostService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalHostService(Service): """ """ def __init__(self, connection, path): super(ExternalHostService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalHostService:%s' % self._path
View Source
def __init__(self, connection, path): super(ExternalHostService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalHostGroupService(Service): """ This service manages a single host group information. Host group is a term of host provider - the host group includes provision details that are applied to new discovered host. Information such as subnet, operating system, domain, etc. """ def __init__(self, connection, path): super(ExternalHostGroupService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get host group information. For example, to get the details of hostgroup `234` of provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/hostgroups/234 .... It will return a response like this: [source,xml] ---- <external_host_group href="/ovirt-engine/api/externalhostproviders/123/hostgroups/234" id="234"> <name>rhel7</name> <architecture_name>x86_64</architecture_name> <domain_name>s.com</domain_name> <operating_system_name>RedHat 7.3</operating_system_name> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_host_group> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalHostGroupService:%s' % self._path
This service manages a single host group information. Host group is a term of host provider - the host group includes provision details that are applied to new discovered host. Information such as subnet, operating system, domain, etc.
View Source
def __init__(self, connection, path): super(ExternalHostGroupService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get host group information. For example, to get the details of hostgroup `234` of provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/hostgroups/234 .... It will return a response like this: [source,xml] ---- <external_host_group href="/ovirt-engine/api/externalhostproviders/123/hostgroups/234" id="234"> <name>rhel7</name> <architecture_name>x86_64</architecture_name> <domain_name>s.com</domain_name> <operating_system_name>RedHat 7.3</operating_system_name> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_host_group> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get host group information.
For example, to get the details of hostgroup 234 of provider 123, send a request like this:
....
GET /ovirt-engine/api/externalhostproviders/123/hostgroups/234
....
It will return a response like this:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalHostGroupsService(Service): """ This service manages hostgroups. """ def __init__(self, connection, path): super(ExternalHostGroupsService, self).__init__(connection, path) self._group_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Get host groups list from external host provider. Host group is a term of host providers - the host group includes provision details. This API returns all possible hostgroups exposed by the external provider. For example, to get the details of all host groups of provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/hostgroups .... The response will be like this: [source,xml] ---- <external_host_groups> <external_host_group href="/ovirt-engine/api/externalhostproviders/123/hostgroups/234" id="234"> <name>rhel7</name> <architecture_name>x86_64</architecture_name> <domain_name>example.com</domain_name> <operating_system_name>RedHat 7.3</operating_system_name> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_host_group> ... </external_host_groups> ---- The order of the returned list of host groups isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of groups to return. If not specified all the groups are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def group_service(self, id): """ This service manages hostgroup instance. """ Service._check_types([ ('id', id, str), ]) return ExternalHostGroupService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.group_service(path) return self.group_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ExternalHostGroupsService:%s' % self._path
This service manages hostgroups.
View Source
def __init__(self, connection, path): super(ExternalHostGroupsService, self).__init__(connection, path) self._group_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Get host groups list from external host provider. Host group is a term of host providers - the host group includes provision details. This API returns all possible hostgroups exposed by the external provider. For example, to get the details of all host groups of provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123/hostgroups .... The response will be like this: [source,xml] ---- <external_host_groups> <external_host_group href="/ovirt-engine/api/externalhostproviders/123/hostgroups/234" id="234"> <name>rhel7</name> <architecture_name>x86_64</architecture_name> <domain_name>example.com</domain_name> <operating_system_name>RedHat 7.3</operating_system_name> <subnet_name>sat0</subnet_name> <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"/> </external_host_group> ... </external_host_groups> ---- The order of the returned list of host groups isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of groups to return. If not specified all the groups are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get host groups list from external host provider.
Host group is a term of host providers - the host group includes provision details. This API returns all possible
hostgroups exposed by the external provider.
For example, to get the details of all host groups of provider 123, send a request like this:
....
GET /ovirt-engine/api/externalhostproviders/123/hostgroups
....
The response will be like this:
[source,xml]
The order of the returned list of host groups isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of groups to return. If not specified all the groups are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def group_service(self, id): """ This service manages hostgroup instance. """ Service._check_types([ ('id', id, str), ]) return ExternalHostGroupService(self._connection, '%s/%s' % (self._path, id))
This service manages hostgroup instance.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.group_service(path) return self.group_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalHostProvidersService(Service): """ """ def __init__(self, connection, path): super(ExternalHostProvidersService, self).__init__(connection, path) self._provider_service = None def add( self, provider, headers=None, query=None, wait=True, **kwargs ): """ Add a new external host provider to the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.ExternalHostProvider), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(provider, headers, query, wait) def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of external host providers. The order of the returned list of host providers isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of providers to return. If not specified all the providers are returned. `search`:: A query string used to restrict the returned external host providers. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def provider_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ExternalHostProviderService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.provider_service(path) return self.provider_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ExternalHostProvidersService:%s' % self._path
View Source
def __init__(self, connection, path): super(ExternalHostProvidersService, self).__init__(connection, path) self._provider_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, provider, headers=None, query=None, wait=True, **kwargs ): """ Add a new external host provider to the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.ExternalHostProvider), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(provider, headers, query, wait)
Add a new external host provider to the system.
#
def
list(
self,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of external host providers. The order of the returned list of host providers isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of providers to return. If not specified all the providers are returned. `search`:: A query string used to restrict the returned external host providers. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of external host providers. The order of the returned list of host providers isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of providers to return. If not specified all the providers are returned.
search:: A query string used to restrict the returned external host providers.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def provider_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ExternalHostProviderService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.provider_service(path) return self.provider_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalHostsService(Service): """ """ def __init__(self, connection, path): super(ExternalHostsService, self).__init__(connection, path) self._host_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Return the list of external hosts. The order of the returned list of hosts isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of hosts to return. If not specified all the hosts are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def host_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ExternalHostService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ExternalHostsService:%s' % self._path
View Source
def __init__(self, connection, path): super(ExternalHostsService, self).__init__(connection, path) self._host_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Return the list of external hosts. The order of the returned list of hosts isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of hosts to return. If not specified all the hosts are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Return the list of external hosts. The order of the returned list of hosts isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of hosts to return. If not specified all the hosts are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def host_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ExternalHostService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalNetworkProviderConfigurationService(Service): """ Describes how an external network provider is provisioned by the system on the host. """ def __init__(self, connection, path): super(ExternalNetworkProviderConfigurationService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about an external network provider on the host. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalNetworkProviderConfigurationService:%s' % self._path
Describes how an external network provider is provisioned by the system on the host.
View Source
def __init__(self, connection, path): super(ExternalNetworkProviderConfigurationService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about an external network provider on the host. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the information about an external network provider on the host.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalNetworkProviderConfigurationsService(Service): """ A service to list all external network providers provisioned by the system on the host. """ def __init__(self, connection, path): super(ExternalNetworkProviderConfigurationsService, self).__init__(connection, path) self._configuration_service = None def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of all external network providers on the host. The order of the returned list of networks is not guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def configuration_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ExternalNetworkProviderConfigurationService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.configuration_service(path) return self.configuration_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ExternalNetworkProviderConfigurationsService:%s' % self._path
A service to list all external network providers provisioned by the system on the host.
View Source
def __init__(self, connection, path): super(ExternalNetworkProviderConfigurationsService, self).__init__(connection, path) self._configuration_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of all external network providers on the host. The order of the returned list of networks is not guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of all external network providers on the host. The order of the returned list of networks is not guaranteed.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def configuration_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ExternalNetworkProviderConfigurationService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.configuration_service(path) return self.configuration_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalProviderService(Service): """ Provides capability to manage external providers. """ def __init__(self, connection, path): super(ExternalProviderService, self).__init__(connection, path) self._certificates_service = None def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait) def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait) def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalProviderService:%s' % self._path
Provides capability to manage external providers.
View Source
def __init__(self, connection, path): super(ExternalProviderService, self).__init__(connection, path) self._certificates_service = None
Creates a new service that will use the given connection and path.
#
def
import_certificates(
self,
certificates=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait)
Import the SSL certificates of the external host provider.
View Source
def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait)
In order to test connectivity for external provider we need to run following request where 123 is an id of a provider.
[source]
POST /ovirt-engine/api/externalhostproviders/123/testconnectivity
This method supports the following parameters:
async_:: Indicates if the test should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path)
A service to view certificates for this external provider.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalProviderCertificateService(Service): """ A service to view specific certificate for external provider. """ def __init__(self, connection, path): super(ExternalProviderCertificateService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get specific certificate. [source] ---- GET /ovirt-engine/api/externalhostproviders/123/certificate/0 ---- And here is sample response: [source,xml] ---- <certificate id="0"> <organization>provider.example.com</organization> <subject>CN=provider.example.com</subject> <content>...</content> </certificate> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalProviderCertificateService:%s' % self._path
A service to view specific certificate for external provider.
View Source
def __init__(self, connection, path): super(ExternalProviderCertificateService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get specific certificate. [source] ---- GET /ovirt-engine/api/externalhostproviders/123/certificate/0 ---- And here is sample response: [source,xml] ---- <certificate id="0"> <organization>provider.example.com</organization> <subject>CN=provider.example.com</subject> <content>...</content> </certificate> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get specific certificate.
[source]
GET /ovirt-engine/api/externalhostproviders/123/certificate/0
And here is sample response:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalProviderCertificatesService(Service): """ A service to view certificates for external provider. """ def __init__(self, connection, path): super(ExternalProviderCertificatesService, self).__init__(connection, path) self._certificate_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the chain of certificates presented by the external provider. [source] ---- GET /ovirt-engine/api/externalhostproviders/123/certificates ---- And here is sample response: [source,xml] ---- <certificates> <certificate id="789">...</certificate> ... </certificates> ---- The order of the returned certificates is always guaranteed to be the sign order: the first is the certificate of the server itself, the second the certificate of the CA that signs the first, so on. This method supports the following parameters: `max`:: Sets the maximum number of certificates to return. If not specified all the certificates are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def certificate_service(self, id): """ Reference to service that manages a specific certificate for this external provider. """ Service._check_types([ ('id', id, str), ]) return ExternalProviderCertificateService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.certificate_service(path) return self.certificate_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ExternalProviderCertificatesService:%s' % self._path
A service to view certificates for external provider.
View Source
def __init__(self, connection, path): super(ExternalProviderCertificatesService, self).__init__(connection, path) self._certificate_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the chain of certificates presented by the external provider. [source] ---- GET /ovirt-engine/api/externalhostproviders/123/certificates ---- And here is sample response: [source,xml] ---- <certificates> <certificate id="789">...</certificate> ... </certificates> ---- The order of the returned certificates is always guaranteed to be the sign order: the first is the certificate of the server itself, the second the certificate of the CA that signs the first, so on. This method supports the following parameters: `max`:: Sets the maximum number of certificates to return. If not specified all the certificates are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the chain of certificates presented by the external provider.
[source]
GET /ovirt-engine/api/externalhostproviders/123/certificates
And here is sample response:
[source,xml]
The order of the returned certificates is always guaranteed to be the sign order: the first is the certificate of the server itself, the second the certificate of the CA that signs the first, so on.
This method supports the following parameters:
max:: Sets the maximum number of certificates to return. If not specified all the certificates are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def certificate_service(self, id): """ Reference to service that manages a specific certificate for this external provider. """ Service._check_types([ ('id', id, str), ]) return ExternalProviderCertificateService(self._connection, '%s/%s' % (self._path, id))
Reference to service that manages a specific certificate for this external provider.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.certificate_service(path) return self.certificate_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalTemplateImportsService(Service): """ Provides capability to import external templates. Currently supports OVA only. """ def __init__(self, connection, path): super(ExternalTemplateImportsService, self).__init__(connection, path) def add( self, import_, headers=None, query=None, wait=True, **kwargs ): """ This operation is used to import a template from external hypervisor. For example import of a template OVA can be facilitated using the following request: [source] ---- POST /externaltemplateimports ---- With request body of type <<types/external_template_import,ExternalTemplateImport>>, for example: [source,xml] ---- <external_template_import> <template> <name>my_template</name> </template> <cluster id="2b18aca2-4469-11eb-9449-482ae35a5f83" /> <storage_domain id="8bb5ade5-e988-4000-8b93-dbfc6717fe50" /> <url>ova:///mnt/ova/ova_template.ova</url> <host id="8bb5ade5-e988-4000-8b93-dbfc6717fe50" /> </external_template_import> ---- """ # Check the types of the parameters: Service._check_types([ ('import_', import_, types.ExternalTemplateImport), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(import_, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalTemplateImportsService:%s' % self._path
Provides capability to import external templates. Currently supports OVA only.
View Source
def __init__(self, connection, path): super(ExternalTemplateImportsService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def add( self, import_, headers=None, query=None, wait=True, **kwargs ): """ This operation is used to import a template from external hypervisor. For example import of a template OVA can be facilitated using the following request: [source] ---- POST /externaltemplateimports ---- With request body of type <<types/external_template_import,ExternalTemplateImport>>, for example: [source,xml] ---- <external_template_import> <template> <name>my_template</name> </template> <cluster id="2b18aca2-4469-11eb-9449-482ae35a5f83" /> <storage_domain id="8bb5ade5-e988-4000-8b93-dbfc6717fe50" /> <url>ova:///mnt/ova/ova_template.ova</url> <host id="8bb5ade5-e988-4000-8b93-dbfc6717fe50" /> </external_template_import> ---- """ # Check the types of the parameters: Service._check_types([ ('import_', import_, types.ExternalTemplateImport), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(import_, headers, query, wait)
This operation is used to import a template from external hypervisor. For example import of a template OVA can be facilitated using the following request:
[source]
POST /externaltemplateimports
With request body of type <
[source,xml]
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalVmImportsService(Service): """ Provides capability to import external virtual machines. """ def __init__(self, connection, path): super(ExternalVmImportsService, self).__init__(connection, path) def add( self, import_, headers=None, query=None, wait=True, **kwargs ): """ This operation is used to import a virtual machine from external hypervisor, such as KVM, XEN or VMware. For example import of a virtual machine from VMware can be facilitated using the following request: [source] ---- POST /externalvmimports ---- With request body of type <<types/external_vm_import,ExternalVmImport>>, for example: [source,xml] ---- <external_vm_import> <vm> <name>my_vm</name> </vm> <cluster id="360014051136c20574f743bdbd28177fd" /> <storage_domain id="8bb5ade5-e988-4000-8b93-dbfc6717fe50" /> <name>vm_name_as_is_in_vmware</name> <sparse>true</sparse> <username>vmware_user</username> <password>123456</password> <provider>VMWARE</provider> <url>vpx://wmware_user@vcenter-host/DataCenter/Cluster/esxi-host?no_verify=1</url> <drivers_iso id="virtio-win-1.6.7.iso" /> </external_vm_import> ---- """ # Check the types of the parameters: Service._check_types([ ('import_', import_, types.ExternalVmImport), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(import_, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalVmImportsService:%s' % self._path
Provides capability to import external virtual machines.
View Source
def __init__(self, connection, path): super(ExternalVmImportsService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def add( self, import_, headers=None, query=None, wait=True, **kwargs ): """ This operation is used to import a virtual machine from external hypervisor, such as KVM, XEN or VMware. For example import of a virtual machine from VMware can be facilitated using the following request: [source] ---- POST /externalvmimports ---- With request body of type <<types/external_vm_import,ExternalVmImport>>, for example: [source,xml] ---- <external_vm_import> <vm> <name>my_vm</name> </vm> <cluster id="360014051136c20574f743bdbd28177fd" /> <storage_domain id="8bb5ade5-e988-4000-8b93-dbfc6717fe50" /> <name>vm_name_as_is_in_vmware</name> <sparse>true</sparse> <username>vmware_user</username> <password>123456</password> <provider>VMWARE</provider> <url>vpx://wmware_user@vcenter-host/DataCenter/Cluster/esxi-host?no_verify=1</url> <drivers_iso id="virtio-win-1.6.7.iso" /> </external_vm_import> ---- """ # Check the types of the parameters: Service._check_types([ ('import_', import_, types.ExternalVmImport), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(import_, headers, query, wait)
This operation is used to import a virtual machine from external hypervisor, such as KVM, XEN or VMware. For example import of a virtual machine from VMware can be facilitated using the following request:
[source]
POST /externalvmimports
With request body of type <
[source,xml]
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class FenceAgentService(Service): """ A service to manage fence agent for a specific host. """ def __init__(self, connection, path): super(FenceAgentService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets details of this fence agent. [source] ---- GET /ovirt-engine/api/hosts/123/fenceagents/0 ---- And here is sample response: [source,xml] ---- <agent id="0"> <type>apc</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <port>9</port> <options>name1=value1, name2=value2</options> </agent> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a fence agent for a specific host. [source] ---- DELETE /ovirt-engine/api/hosts/123/fenceagents/0 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, agent, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update a fencing-agent. This method supports the following parameters: `agent`:: Fence agent details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('agent', agent, types.Agent), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(agent, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'FenceAgentService:%s' % self._path
A service to manage fence agent for a specific host.
View Source
def __init__(self, connection, path): super(FenceAgentService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets details of this fence agent. [source] ---- GET /ovirt-engine/api/hosts/123/fenceagents/0 ---- And here is sample response: [source,xml] ---- <agent id="0"> <type>apc</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <port>9</port> <options>name1=value1, name2=value2</options> </agent> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets details of this fence agent.
[source]
GET /ovirt-engine/api/hosts/123/fenceagents/0
And here is sample response:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a fence agent for a specific host. [source] ---- DELETE /ovirt-engine/api/hosts/123/fenceagents/0 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes a fence agent for a specific host.
[source]
DELETE /ovirt-engine/api/hosts/123/fenceagents/0
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, agent, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update a fencing-agent. This method supports the following parameters: `agent`:: Fence agent details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('agent', agent, types.Agent), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(agent, headers, query, wait)
Update a fencing-agent.
This method supports the following parameters:
agent:: Fence agent details.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class FenceAgentsService(Service): """ A service to manage fence agents for a specific host. """ def __init__(self, connection, path): super(FenceAgentsService, self).__init__(connection, path) self._agent_service = None def add( self, agent, headers=None, query=None, wait=True, **kwargs ): """ Add a new fencing-agent to the host. [source] ---- POST /ovirt-engine/api/hosts/123/fenceagents You should consult the /usr/sbin/fence_<agent_name> manual page for the legal parameters to [name1=value1, name2=value2,...] in the options field. If any parameter in options appears by name that means that it is mandatory. For example in <options>slot=7[,name1=value1, name2=value2,...]</options> slot is mandatory. ---- apc, bladecenter, wti fencing agent/s sample request: [source,xml] <agent> <type>apc</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <port>9</port> <options>slot=7[,name1=value1, name2=value2,...]</options> </agent> apc_snmp, hpblade, ilo, ilo2, ilo_ssh, redfish, rsa fencing agent/s sample request: [source,xml] <agent> <type>apc_snmp</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <port>9</port> <options>[name1=value1, name2=value2,...]</options> </agent> cisco_ucs, drac5, eps fencing agent/s sample request: [source,xml] <agent> <type>cisco_ucs</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <options>slot=7[,name1=value1, name2=value2,...]</options> </agent> drac7, ilo3, ilo4, ipmilan, rsb fencing agent/s sample request: [source,xml] <agent> <type>drac7</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <options>[name1=value1, name2=value2,...]</options> </agent> """ # Check the types of the parameters: Service._check_types([ ('agent', agent, types.Agent), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(agent, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of fencing agents configured for the host. [source] ---- GET /ovirt-engine/api/hosts/123/fenceagents ---- And here is sample response: [source,xml] ---- <agents> <agent id="0"> <type>apc</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <port>9</port> <options>name1=value1, name2=value2</options> </agent> </agents> ---- The order of the returned list of fencing agents isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of agents to return. If not specified all the agents are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def agent_service(self, id): """ Reference to service that manages a specific fence agent for this host. """ Service._check_types([ ('id', id, str), ]) return FenceAgentService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.agent_service(path) return self.agent_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'FenceAgentsService:%s' % self._path
A service to manage fence agents for a specific host.
View Source
def __init__(self, connection, path): super(FenceAgentsService, self).__init__(connection, path) self._agent_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, agent, headers=None, query=None, wait=True, **kwargs ): """ Add a new fencing-agent to the host. [source] ---- POST /ovirt-engine/api/hosts/123/fenceagents You should consult the /usr/sbin/fence_<agent_name> manual page for the legal parameters to [name1=value1, name2=value2,...] in the options field. If any parameter in options appears by name that means that it is mandatory. For example in <options>slot=7[,name1=value1, name2=value2,...]</options> slot is mandatory. ---- apc, bladecenter, wti fencing agent/s sample request: [source,xml] <agent> <type>apc</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <port>9</port> <options>slot=7[,name1=value1, name2=value2,...]</options> </agent> apc_snmp, hpblade, ilo, ilo2, ilo_ssh, redfish, rsa fencing agent/s sample request: [source,xml] <agent> <type>apc_snmp</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <port>9</port> <options>[name1=value1, name2=value2,...]</options> </agent> cisco_ucs, drac5, eps fencing agent/s sample request: [source,xml] <agent> <type>cisco_ucs</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <options>slot=7[,name1=value1, name2=value2,...]</options> </agent> drac7, ilo3, ilo4, ipmilan, rsb fencing agent/s sample request: [source,xml] <agent> <type>drac7</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <options>[name1=value1, name2=value2,...]</options> </agent> """ # Check the types of the parameters: Service._check_types([ ('agent', agent, types.Agent), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(agent, headers, query, wait)
Add a new fencing-agent to the host.
[source]
POST /ovirt-engine/api/hosts/123/fenceagents
You should consult the /usr/sbin/fence_
slot is mandatory.
apc, bladecenter, wti fencing agent/s sample request:
[source,xml]
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of fencing agents configured for the host. [source] ---- GET /ovirt-engine/api/hosts/123/fenceagents ---- And here is sample response: [source,xml] ---- <agents> <agent id="0"> <type>apc</type> <order>1</order> <ip>192.168.1.101</ip> <user>user</user> <password>xxx</password> <port>9</port> <options>name1=value1, name2=value2</options> </agent> </agents> ---- The order of the returned list of fencing agents isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of agents to return. If not specified all the agents are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of fencing agents configured for the host.
[source]
GET /ovirt-engine/api/hosts/123/fenceagents
And here is sample response:
[source,xml]
The order of the returned list of fencing agents isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of agents to return. If not specified all the agents are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def agent_service(self, id): """ Reference to service that manages a specific fence agent for this host. """ Service._check_types([ ('id', id, str), ]) return FenceAgentService(self._connection, '%s/%s' % (self._path, id))
Reference to service that manages a specific fence agent for this host.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.agent_service(path) return self.agent_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class FileService(Service): """ """ def __init__(self, connection, path): super(FileService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'FileService:%s' % self._path
View Source
def __init__(self, connection, path): super(FileService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class FilesService(Service): """ Provides a way for clients to list available files. This service is specifically targeted to ISO storage domains, which contain ISO images and virtual floppy disks (VFDs) that an administrator uploads. The addition of a CD-ROM device to a virtual machine requires an ISO image from the files of an ISO storage domain. """ def __init__(self, connection, path): super(FilesService, self).__init__(connection, path) self._file_service = None def list( self, case_sensitive=None, follow=None, max=None, refresh=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of ISO images and virtual floppy disks available in the storage domain. The order of the returned list is not guaranteed. If the `refresh` parameter is `false`, the returned list may not reflect recent changes to the storage domain; for example, it may not contain a new ISO file that was recently added. This is because the server caches the list of files to improve performance. To get the very latest results, set the `refresh` parameter to `true`. The default value of the `refresh` parameter is `true`, but it can be changed using the configuration value `ForceRefreshDomainFilesByDefault`: [source] ---- # engine-config -s ForceRefreshDomainFilesByDefault=false ---- IMPORTANT: Setting the value of the `refresh` parameter to `true` has an impact on the performance of the server. Use it only if necessary. This method supports the following parameters: `max`:: Sets the maximum number of files to return. If not specified, all the files are returned. `search`:: A query string used to restrict the returned files. `case_sensitive`:: Indicates if the search performed using the `search` parameter should take case into account. The default value is `true`. `refresh`:: Indicates whether the list of files should be refreshed from the storage domain, rather than showing cached results that are updated at certain intervals. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('refresh', refresh, bool), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if refresh is not None: refresh = Writer.render_boolean(refresh) query['refresh'] = refresh if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def file_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return FileService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.file_service(path) return self.file_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'FilesService:%s' % self._path
Provides a way for clients to list available files. This service is specifically targeted to ISO storage domains, which contain ISO images and virtual floppy disks (VFDs) that an administrator uploads. The addition of a CD-ROM device to a virtual machine requires an ISO image from the files of an ISO storage domain.
View Source
def __init__(self, connection, path): super(FilesService, self).__init__(connection, path) self._file_service = None
Creates a new service that will use the given connection and path.
#
def
list(
self,
case_sensitive=None,
follow=None,
max=None,
refresh=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, follow=None, max=None, refresh=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of ISO images and virtual floppy disks available in the storage domain. The order of the returned list is not guaranteed. If the `refresh` parameter is `false`, the returned list may not reflect recent changes to the storage domain; for example, it may not contain a new ISO file that was recently added. This is because the server caches the list of files to improve performance. To get the very latest results, set the `refresh` parameter to `true`. The default value of the `refresh` parameter is `true`, but it can be changed using the configuration value `ForceRefreshDomainFilesByDefault`: [source] ---- # engine-config -s ForceRefreshDomainFilesByDefault=false ---- IMPORTANT: Setting the value of the `refresh` parameter to `true` has an impact on the performance of the server. Use it only if necessary. This method supports the following parameters: `max`:: Sets the maximum number of files to return. If not specified, all the files are returned. `search`:: A query string used to restrict the returned files. `case_sensitive`:: Indicates if the search performed using the `search` parameter should take case into account. The default value is `true`. `refresh`:: Indicates whether the list of files should be refreshed from the storage domain, rather than showing cached results that are updated at certain intervals. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('refresh', refresh, bool), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if refresh is not None: refresh = Writer.render_boolean(refresh) query['refresh'] = refresh if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of ISO images and virtual floppy disks available in the storage domain. The order of
the returned list is not guaranteed.
If the refresh parameter is false, the returned list may not reflect recent changes to the storage domain;
for example, it may not contain a new ISO file that was recently added. This is because the
server caches the list of files to improve performance. To get the very latest results, set the refresh
parameter to true.
The default value of the refresh parameter is true, but it can be changed using the configuration value
ForceRefreshDomainFilesByDefault:
[source]
# engine-config -s ForceRefreshDomainFilesByDefault=false
IMPORTANT: Setting the value of the refresh parameter to true has an impact on the performance of the
server. Use it only if necessary.
This method supports the following parameters:
max:: Sets the maximum number of files to return. If not specified, all the files are returned.
search:: A query string used to restrict the returned files.
case_sensitive:: Indicates if the search performed using the search parameter should take case into
account. The default value is true.
refresh:: Indicates whether the list of files should be refreshed from the storage domain, rather than showing cached
results that are updated at certain intervals.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def file_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return FileService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.file_service(path) return self.file_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class FilterService(Service): """ """ def __init__(self, connection, path): super(FilterService, self).__init__(connection, path) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'FilterService:%s' % self._path
View Source
def __init__(self, connection, path): super(FilterService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class FiltersService(Service): """ Manages the filters used by an scheduling policy. """ def __init__(self, connection, path): super(FiltersService, self).__init__(connection, path) self._filter_service = None def add( self, filter, headers=None, query=None, wait=True, **kwargs ): """ Add a filter to a specified user defined scheduling policy. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, types.Filter), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(filter, headers, query, wait) def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of filters used by the scheduling policy. The order of the returned list of filters isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of filters to return. If not specified all the filters are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def filter_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return FilterService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.filter_service(path) return self.filter_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'FiltersService:%s' % self._path
Manages the filters used by an scheduling policy.
View Source
def __init__(self, connection, path): super(FiltersService, self).__init__(connection, path) self._filter_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, filter, headers=None, query=None, wait=True, **kwargs ): """ Add a filter to a specified user defined scheduling policy. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, types.Filter), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(filter, headers, query, wait)
Add a filter to a specified user defined scheduling policy.
#
def
list(
self,
filter=None,
follow=None,
max=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of filters used by the scheduling policy. The order of the returned list of filters isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of filters to return. If not specified all the filters are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of filters used by the scheduling policy. The order of the returned list of filters isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of filters to return. If not specified all the filters are returned.
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def filter_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return FilterService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.filter_service(path) return self.filter_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class FollowService(Service): """ """ def __init__(self, connection, path): super(FollowService, self).__init__(connection, path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'FollowService:%s' % self._path
View Source
def __init__(self, connection, path): super(FollowService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class GlusterBricksService(Service): """ This service manages the gluster bricks in a gluster volume """ def __init__(self, connection, path): super(GlusterBricksService, self).__init__(connection, path) self._brick_service = None def activate( self, async_=None, bricks=None, headers=None, query=None, wait=True, **kwargs ): """ Activate the bricks post data migration of remove brick operation. Used to activate brick(s) once the data migration from bricks is complete but user no longer wishes to remove bricks. The bricks that were previously marked for removal will now be used as normal bricks. For example, to retain the bricks that on glustervolume `123` from which data was migrated, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/activate ---- With a request body like this: [source,xml] ---- <action> <bricks> <brick> <name>host1:/rhgs/brick1</name> </brick> </bricks> </action> ---- This method supports the following parameters: `bricks`:: The list of bricks that need to be re-activated. `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('bricks', bricks, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, bricks=bricks, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait) def add( self, bricks, replica_count=None, stripe_count=None, headers=None, query=None, wait=True, **kwargs ): """ Adds a list of bricks to gluster volume. Used to expand a gluster volume by adding bricks. For replicated volume types, the parameter `replica_count` needs to be passed. In case the replica count is being increased, then the number of bricks needs to be equivalent to the number of replica sets. For example, to add bricks to gluster volume `123`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks ---- With a request body like this: [source,xml] ---- <bricks> <brick> <server_id>111</server_id> <brick_dir>/export/data/brick3</brick_dir> </brick> </bricks> ---- This method supports the following parameters: `bricks`:: The list of bricks to be added to the volume `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bricks', bricks, list), ('replica_count', replica_count, int), ('stripe_count', stripe_count, int), ]) # Build the URL: query = query or {} if replica_count is not None: replica_count = Writer.render_integer(replica_count) query['replica_count'] = replica_count if stripe_count is not None: stripe_count = Writer.render_integer(stripe_count) query['stripe_count'] = stripe_count # Send the request and wait for the response: return self._internal_add(bricks, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the bricks of a gluster volume. For example, to list bricks of gluster volume `123`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks ---- Provides an output as below: [source,xml] ---- <bricks> <brick id="234"> <name>host1:/rhgs/data/brick1</name> <brick_dir>/rhgs/data/brick1</brick_dir> <server_id>111</server_id> <status>up</status> </brick> <brick id="233"> <name>host2:/rhgs/data/brick1</name> <brick_dir>/rhgs/data/brick1</brick_dir> <server_id>222</server_id> <status>up</status> </brick> </bricks> ---- The order of the returned list is based on the brick order provided at gluster volume creation. This method supports the following parameters: `max`:: Sets the maximum number of bricks to return. If not specified all the bricks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def migrate( self, async_=None, bricks=None, headers=None, query=None, wait=True, **kwargs ): """ Start migration of data prior to removing bricks. Removing bricks is a two-step process, where the data on bricks to be removed, is first migrated to remaining bricks. Once migration is completed the removal of bricks is confirmed via the API <<services/gluster_bricks/methods/remove, remove>>. If at any point, the action needs to be cancelled <<services/gluster_bricks/methods/stop_migrate, stopmigrate>> has to be called. For instance, to delete a brick from a gluster volume with id `123`, send a request: [source] ---- POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/migrate ---- With a request body like this: [source,xml] ---- <action> <bricks> <brick> <name>host1:/rhgs/brick1</name> </brick> </bricks> </action> ---- The migration process can be tracked from the job id returned from the API using <<services/job/methods/get, job>> and steps in job using <<services/step/methods/get, step>> This method supports the following parameters: `bricks`:: List of bricks for which data migration needs to be started. `async_`:: Indicates if the migration should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('bricks', bricks, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, bricks=bricks, ) # Send the request and wait for the response: return self._internal_action(action, 'migrate', None, headers, query, wait) def remove( self, bricks=None, replica_count=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes bricks from gluster volume. The recommended way to remove bricks without data loss is to first migrate the data using <<services/gluster_bricks/methods/stop_migrate, stopmigrate>> and then removing them. If migrate was not called on bricks prior to remove, the bricks are removed without data migration which may lead to data loss. For example, to delete the bricks from gluster volume `123`, send a request like this: [source] ---- DELETE /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks ---- With a request body like this: [source,xml] ---- <bricks> <brick> <name>host:brick_directory</name> </brick> </bricks> ---- This method supports the following parameters: `bricks`:: The list of bricks to be removed `replica_count`:: Replica count of volume post add operation. `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bricks', bricks, list), ('replica_count', replica_count, int), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if bricks is not None: query['bricks'] = bricks if replica_count is not None: replica_count = Writer.render_integer(replica_count) query['replica_count'] = replica_count if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def stop_migrate( self, async_=None, bricks=None, headers=None, query=None, wait=True, **kwargs ): """ Stops migration of data from bricks for a remove brick operation. To cancel data migration that was started as part of the 2-step remove brick process in case the user wishes to continue using the bricks. The bricks that were marked for removal will function as normal bricks post this operation. For example, to stop migration of data from the bricks of gluster volume `123`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/stopmigrate ---- With a request body like this: [source,xml] ---- <bricks> <brick> <name>host:brick_directory</name> </brick> </bricks> ---- This method supports the following parameters: `bricks`:: List of bricks for which data migration needs to be stopped. This list should match the arguments passed to <<services/gluster_bricks/methods/migrate, migrate>>. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('bricks', bricks, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, bricks=bricks, ) # Send the request and wait for the response: return self._internal_action(action, 'stopmigrate', None, headers, query, wait) def brick_service(self, id): """ Returns a reference to the service managing a single gluster brick. """ Service._check_types([ ('id', id, str), ]) return GlusterBrickService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.brick_service(path) return self.brick_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'GlusterBricksService:%s' % self._path
This service manages the gluster bricks in a gluster volume
View Source
def __init__(self, connection, path): super(GlusterBricksService, self).__init__(connection, path) self._brick_service = None
Creates a new service that will use the given connection and path.
View Source
def activate( self, async_=None, bricks=None, headers=None, query=None, wait=True, **kwargs ): """ Activate the bricks post data migration of remove brick operation. Used to activate brick(s) once the data migration from bricks is complete but user no longer wishes to remove bricks. The bricks that were previously marked for removal will now be used as normal bricks. For example, to retain the bricks that on glustervolume `123` from which data was migrated, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/activate ---- With a request body like this: [source,xml] ---- <action> <bricks> <brick> <name>host1:/rhgs/brick1</name> </brick> </bricks> </action> ---- This method supports the following parameters: `bricks`:: The list of bricks that need to be re-activated. `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('bricks', bricks, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, bricks=bricks, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait)
Activate the bricks post data migration of remove brick operation.
Used to activate brick(s) once the data migration from bricks is complete but user no longer wishes to remove
bricks. The bricks that were previously marked for removal will now be used as normal bricks.
For example, to retain the bricks that on glustervolume 123 from which data was migrated, send a request like
this:
[source]
POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/activate
With a request body like this:
[source,xml]
This method supports the following parameters:
bricks:: The list of bricks that need to be re-activated.
async_:: Indicates if the activation should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
add(
self,
bricks,
replica_count=None,
stripe_count=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def add( self, bricks, replica_count=None, stripe_count=None, headers=None, query=None, wait=True, **kwargs ): """ Adds a list of bricks to gluster volume. Used to expand a gluster volume by adding bricks. For replicated volume types, the parameter `replica_count` needs to be passed. In case the replica count is being increased, then the number of bricks needs to be equivalent to the number of replica sets. For example, to add bricks to gluster volume `123`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks ---- With a request body like this: [source,xml] ---- <bricks> <brick> <server_id>111</server_id> <brick_dir>/export/data/brick3</brick_dir> </brick> </bricks> ---- This method supports the following parameters: `bricks`:: The list of bricks to be added to the volume `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bricks', bricks, list), ('replica_count', replica_count, int), ('stripe_count', stripe_count, int), ]) # Build the URL: query = query or {} if replica_count is not None: replica_count = Writer.render_integer(replica_count) query['replica_count'] = replica_count if stripe_count is not None: stripe_count = Writer.render_integer(stripe_count) query['stripe_count'] = stripe_count # Send the request and wait for the response: return self._internal_add(bricks, headers, query, wait)
Adds a list of bricks to gluster volume.
Used to expand a gluster volume by adding bricks. For replicated volume types, the parameter replica_count
needs to be passed. In case the replica count is being increased, then the number of bricks needs to be
equivalent to the number of replica sets.
For example, to add bricks to gluster volume 123, send a request like this:
[source]
POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks
With a request body like this:
[source,xml]
This method supports the following parameters:
bricks:: The list of bricks to be added to the volume
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the bricks of a gluster volume. For example, to list bricks of gluster volume `123`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks ---- Provides an output as below: [source,xml] ---- <bricks> <brick id="234"> <name>host1:/rhgs/data/brick1</name> <brick_dir>/rhgs/data/brick1</brick_dir> <server_id>111</server_id> <status>up</status> </brick> <brick id="233"> <name>host2:/rhgs/data/brick1</name> <brick_dir>/rhgs/data/brick1</brick_dir> <server_id>222</server_id> <status>up</status> </brick> </bricks> ---- The order of the returned list is based on the brick order provided at gluster volume creation. This method supports the following parameters: `max`:: Sets the maximum number of bricks to return. If not specified all the bricks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists the bricks of a gluster volume.
For example, to list bricks of gluster volume 123, send a request like this:
[source]
GET /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks
Provides an output as below:
[source,xml]
The order of the returned list is based on the brick order provided at gluster volume creation.
This method supports the following parameters:
max:: Sets the maximum number of bricks to return. If not specified all the bricks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def migrate( self, async_=None, bricks=None, headers=None, query=None, wait=True, **kwargs ): """ Start migration of data prior to removing bricks. Removing bricks is a two-step process, where the data on bricks to be removed, is first migrated to remaining bricks. Once migration is completed the removal of bricks is confirmed via the API <<services/gluster_bricks/methods/remove, remove>>. If at any point, the action needs to be cancelled <<services/gluster_bricks/methods/stop_migrate, stopmigrate>> has to be called. For instance, to delete a brick from a gluster volume with id `123`, send a request: [source] ---- POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/migrate ---- With a request body like this: [source,xml] ---- <action> <bricks> <brick> <name>host1:/rhgs/brick1</name> </brick> </bricks> </action> ---- The migration process can be tracked from the job id returned from the API using <<services/job/methods/get, job>> and steps in job using <<services/step/methods/get, step>> This method supports the following parameters: `bricks`:: List of bricks for which data migration needs to be started. `async_`:: Indicates if the migration should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('bricks', bricks, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, bricks=bricks, ) # Send the request and wait for the response: return self._internal_action(action, 'migrate', None, headers, query, wait)
Start migration of data prior to removing bricks.
Removing bricks is a two-step process, where the data on bricks to be removed, is first migrated to remaining
bricks. Once migration is completed the removal of bricks is confirmed via the API
<123, send a request:
[source]
POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/migrate
With a request body like this:
[source,xml]
The migration process can be tracked from the job id returned from the API using
<
This method supports the following parameters:
bricks:: List of bricks for which data migration needs to be started.
async_:: Indicates if the migration should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
remove(
self,
bricks=None,
replica_count=None,
async_=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def remove( self, bricks=None, replica_count=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes bricks from gluster volume. The recommended way to remove bricks without data loss is to first migrate the data using <<services/gluster_bricks/methods/stop_migrate, stopmigrate>> and then removing them. If migrate was not called on bricks prior to remove, the bricks are removed without data migration which may lead to data loss. For example, to delete the bricks from gluster volume `123`, send a request like this: [source] ---- DELETE /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks ---- With a request body like this: [source,xml] ---- <bricks> <brick> <name>host:brick_directory</name> </brick> </bricks> ---- This method supports the following parameters: `bricks`:: The list of bricks to be removed `replica_count`:: Replica count of volume post add operation. `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bricks', bricks, list), ('replica_count', replica_count, int), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if bricks is not None: query['bricks'] = bricks if replica_count is not None: replica_count = Writer.render_integer(replica_count) query['replica_count'] = replica_count if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes bricks from gluster volume.
The recommended way to remove bricks without data loss is to first migrate the data using
<123, send a request like this:
[source]
DELETE /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks
With a request body like this:
[source,xml]
This method supports the following parameters:
bricks:: The list of bricks to be removed
replica_count:: Replica count of volume post add operation.
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
stop_migrate(
self,
async_=None,
bricks=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def stop_migrate( self, async_=None, bricks=None, headers=None, query=None, wait=True, **kwargs ): """ Stops migration of data from bricks for a remove brick operation. To cancel data migration that was started as part of the 2-step remove brick process in case the user wishes to continue using the bricks. The bricks that were marked for removal will function as normal bricks post this operation. For example, to stop migration of data from the bricks of gluster volume `123`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/stopmigrate ---- With a request body like this: [source,xml] ---- <bricks> <brick> <name>host:brick_directory</name> </brick> </bricks> ---- This method supports the following parameters: `bricks`:: List of bricks for which data migration needs to be stopped. This list should match the arguments passed to <<services/gluster_bricks/methods/migrate, migrate>>. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('bricks', bricks, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, bricks=bricks, ) # Send the request and wait for the response: return self._internal_action(action, 'stopmigrate', None, headers, query, wait)
Stops migration of data from bricks for a remove brick operation.
To cancel data migration that was started as part of the 2-step remove brick process in case the user wishes to
continue using the bricks. The bricks that were marked for removal will function as normal bricks post this
operation.
For example, to stop migration of data from the bricks of gluster volume 123, send a request like this:
[source]
POST /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/stopmigrate
With a request body like this:
[source,xml]
This method supports the following parameters:
bricks:: List of bricks for which data migration needs to be stopped. This list should match the arguments passed to
<
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def brick_service(self, id): """ Returns a reference to the service managing a single gluster brick. """ Service._check_types([ ('id', id, str), ]) return GlusterBrickService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service managing a single gluster brick.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.brick_service(path) return self.brick_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class GlusterHookService(Service): """ """ def __init__(self, connection, path): super(GlusterHookService, self).__init__(connection, path) def disable( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Resolves status conflict of hook among servers in cluster by disabling Gluster hook in all servers of the cluster. This updates the hook status to `DISABLED` in database. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'disable', None, headers, query, wait) def enable( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Resolves status conflict of hook among servers in cluster by disabling Gluster hook in all servers of the cluster. This updates the hook status to `DISABLED` in database. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'enable', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the this Gluster hook from all servers in cluster and deletes it from the database. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def resolve( self, async_=None, host=None, resolution_type=None, headers=None, query=None, wait=True, **kwargs ): """ Resolves missing hook conflict depending on the resolution type. For `ADD` resolves by copying hook stored in engine database to all servers where the hook is missing. The engine maintains a list of all servers where hook is missing. For `COPY` resolves conflict in hook content by copying hook stored in engine database to all servers where the hook is missing. The engine maintains a list of all servers where the content is conflicting. If a host id is passed as parameter, the hook content from the server is used as the master to copy to other servers in cluster. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('host', host, types.Host), ('resolution_type', resolution_type, str), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, host=host, resolution_type=resolution_type, ) # Send the request and wait for the response: return self._internal_action(action, 'resolve', None, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'GlusterHookService:%s' % self._path
View Source
def __init__(self, connection, path): super(GlusterHookService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def disable( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Resolves status conflict of hook among servers in cluster by disabling Gluster hook in all servers of the cluster. This updates the hook status to `DISABLED` in database. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'disable', None, headers, query, wait)
Resolves status conflict of hook among servers in cluster by disabling Gluster hook in all servers of the
cluster. This updates the hook status to DISABLED in database.
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def enable( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Resolves status conflict of hook among servers in cluster by disabling Gluster hook in all servers of the cluster. This updates the hook status to `DISABLED` in database. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'enable', None, headers, query, wait)
Resolves status conflict of hook among servers in cluster by disabling Gluster hook in all servers of the
cluster. This updates the hook status to DISABLED in database.
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the this Gluster hook from all servers in cluster and deletes it from the database. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the this Gluster hook from all servers in cluster and deletes it from the database.
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
resolve(
self,
async_=None,
host=None,
resolution_type=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def resolve( self, async_=None, host=None, resolution_type=None, headers=None, query=None, wait=True, **kwargs ): """ Resolves missing hook conflict depending on the resolution type. For `ADD` resolves by copying hook stored in engine database to all servers where the hook is missing. The engine maintains a list of all servers where hook is missing. For `COPY` resolves conflict in hook content by copying hook stored in engine database to all servers where the hook is missing. The engine maintains a list of all servers where the content is conflicting. If a host id is passed as parameter, the hook content from the server is used as the master to copy to other servers in cluster. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('host', host, types.Host), ('resolution_type', resolution_type, str), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, host=host, resolution_type=resolution_type, ) # Send the request and wait for the response: return self._internal_action(action, 'resolve', None, headers, query, wait)
Resolves missing hook conflict depending on the resolution type.
For ADD resolves by copying hook stored in engine database to all servers where the hook is missing. The
engine maintains a list of all servers where hook is missing.
For COPY resolves conflict in hook content by copying hook stored in engine database to all servers where
the hook is missing. The engine maintains a list of all servers where the content is conflicting. If a host
id is passed as parameter, the hook content from the server is used as the master to copy to other servers
in cluster.
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class GlusterHooksService(Service): """ """ def __init__(self, connection, path): super(GlusterHooksService, self).__init__(connection, path) self._hook_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of hooks. The order of the returned list of hooks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of hooks to return. If not specified all the hooks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def hook_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return GlusterHookService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.hook_service(path) return self.hook_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'GlusterHooksService:%s' % self._path
View Source
def __init__(self, connection, path): super(GlusterHooksService, self).__init__(connection, path) self._hook_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of hooks. The order of the returned list of hooks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of hooks to return. If not specified all the hooks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of hooks. The order of the returned list of hooks isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of hooks to return. If not specified all the hooks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def hook_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return GlusterHookService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.hook_service(path) return self.hook_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class GlusterVolumesService(Service): """ This service manages a collection of gluster volumes available in a cluster. """ def __init__(self, connection, path): super(GlusterVolumesService, self).__init__(connection, path) self._volume_service = None def add( self, volume, headers=None, query=None, wait=True, **kwargs ): """ Creates a new gluster volume. The volume is created based on properties of the `volume` parameter. The properties `name`, `volume_type` and `bricks` are required. For example, to add a volume with name `myvolume` to the cluster `123`, send the following request: [source] ---- POST /ovirt-engine/api/clusters/123/glustervolumes ---- With the following request body: [source,xml] ---- <gluster_volume> <name>myvolume</name> <volume_type>replicate</volume_type> <replica_count>3</replica_count> <bricks> <brick> <server_id>server1</server_id> <brick_dir>/exp1</brick_dir> </brick> <brick> <server_id>server2</server_id> <brick_dir>/exp1</brick_dir> </brick> <brick> <server_id>server3</server_id> <brick_dir>/exp1</brick_dir> </brick> <bricks> </gluster_volume> ---- This method supports the following parameters: `volume`:: The gluster volume definition from which to create the volume is passed as input and the newly created volume is returned. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('volume', volume, types.GlusterVolume), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(volume, headers, query, wait) def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all gluster volumes in the cluster. For example, to list all Gluster Volumes in cluster `456`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/456/glustervolumes ---- The order of the returned list of volumes isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of volumes to return. If not specified all the volumes are returned. `search`:: A query string used to restrict the returned volumes. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def volume_service(self, id): """ Reference to a service managing gluster volume. """ Service._check_types([ ('id', id, str), ]) return GlusterVolumeService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.volume_service(path) return self.volume_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'GlusterVolumesService:%s' % self._path
This service manages a collection of gluster volumes available in a cluster.
View Source
def __init__(self, connection, path): super(GlusterVolumesService, self).__init__(connection, path) self._volume_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, volume, headers=None, query=None, wait=True, **kwargs ): """ Creates a new gluster volume. The volume is created based on properties of the `volume` parameter. The properties `name`, `volume_type` and `bricks` are required. For example, to add a volume with name `myvolume` to the cluster `123`, send the following request: [source] ---- POST /ovirt-engine/api/clusters/123/glustervolumes ---- With the following request body: [source,xml] ---- <gluster_volume> <name>myvolume</name> <volume_type>replicate</volume_type> <replica_count>3</replica_count> <bricks> <brick> <server_id>server1</server_id> <brick_dir>/exp1</brick_dir> </brick> <brick> <server_id>server2</server_id> <brick_dir>/exp1</brick_dir> </brick> <brick> <server_id>server3</server_id> <brick_dir>/exp1</brick_dir> </brick> <bricks> </gluster_volume> ---- This method supports the following parameters: `volume`:: The gluster volume definition from which to create the volume is passed as input and the newly created volume is returned. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('volume', volume, types.GlusterVolume), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(volume, headers, query, wait)
Creates a new gluster volume.
The volume is created based on properties of the volume parameter. The properties name, volume_type and
bricks are required.
For example, to add a volume with name myvolume to the cluster 123, send the following request:
[source]
POST /ovirt-engine/api/clusters/123/glustervolumes
With the following request body:
[source,xml]
This method supports the following parameters:
volume:: The gluster volume definition from which to create the volume is passed as input and the newly created
volume is returned.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
list(
self,
case_sensitive=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all gluster volumes in the cluster. For example, to list all Gluster Volumes in cluster `456`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/456/glustervolumes ---- The order of the returned list of volumes isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of volumes to return. If not specified all the volumes are returned. `search`:: A query string used to restrict the returned volumes. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists all gluster volumes in the cluster.
For example, to list all Gluster Volumes in cluster 456, send a request like
this:
[source]
GET /ovirt-engine/api/clusters/456/glustervolumes
The order of the returned list of volumes isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of volumes to return. If not specified all the volumes are returned.
search:: A query string used to restrict the returned volumes.
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def volume_service(self, id): """ Reference to a service managing gluster volume. """ Service._check_types([ ('id', id, str), ]) return GlusterVolumeService(self._connection, '%s/%s' % (self._path, id))
Reference to a service managing gluster volume.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.volume_service(path) return self.volume_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class GroupService(Service): """ Manages a group of users. Use this service to either get groups details or remove groups. In order to add new groups please use <<services/groups, service>> that manages the collection of groups. """ def __init__(self, connection, path): super(GroupService, self).__init__(connection, path) self._permissions_service = None self._roles_service = None self._tags_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the system group information. Usage: .... GET /ovirt-engine/api/groups/123 .... Will return the group information: [source,xml] ---- <group href="/ovirt-engine/api/groups/123" id="123"> <name>mygroup</name> <link href="/ovirt-engine/api/groups/123/roles" rel="roles"/> <link href="/ovirt-engine/api/groups/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/groups/123/tags" rel="tags"/> <domain_entry_id>476652557A382F67696B6D2B32762B37796E46476D513D3D</domain_entry_id> <namespace>DC=example,DC=com</namespace> <domain href="/ovirt-engine/api/domains/ABCDEF" id="ABCDEF"> <name>myextension-authz</name> </domain> </group> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the system group. Usage: .... DELETE /ovirt-engine/api/groups/123 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def permissions_service(self): """ Reference to the service that manages the collection of permissions assigned to this system group. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def roles_service(self): """ Reference to the service that manages the collection of roles assigned to this system group. """ return AssignedRolesService(self._connection, '%s/roles' % self._path) def tags_service(self): """ Reference to the service that manages the collection of tags assigned to this system group. """ return AssignedTagsService(self._connection, '%s/tags' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'roles': return self.roles_service() if path.startswith('roles/'): return self.roles_service().service(path[6:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'GroupService:%s' % self._path
Manages a group of users. Use this service to either get groups details or remove groups. In order
to add new groups please use <
View Source
def __init__(self, connection, path): super(GroupService, self).__init__(connection, path) self._permissions_service = None self._roles_service = None self._tags_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the system group information. Usage: .... GET /ovirt-engine/api/groups/123 .... Will return the group information: [source,xml] ---- <group href="/ovirt-engine/api/groups/123" id="123"> <name>mygroup</name> <link href="/ovirt-engine/api/groups/123/roles" rel="roles"/> <link href="/ovirt-engine/api/groups/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/groups/123/tags" rel="tags"/> <domain_entry_id>476652557A382F67696B6D2B32762B37796E46476D513D3D</domain_entry_id> <namespace>DC=example,DC=com</namespace> <domain href="/ovirt-engine/api/domains/ABCDEF" id="ABCDEF"> <name>myextension-authz</name> </domain> </group> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets the system group information. Usage: .... GET /ovirt-engine/api/groups/123 .... Will return the group information:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the system group. Usage: .... DELETE /ovirt-engine/api/groups/123 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the system group. Usage: .... DELETE /ovirt-engine/api/groups/123 ....
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def permissions_service(self): """ Reference to the service that manages the collection of permissions assigned to this system group. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
Reference to the service that manages the collection of permissions assigned to this system group.
View Source
def roles_service(self): """ Reference to the service that manages the collection of roles assigned to this system group. """ return AssignedRolesService(self._connection, '%s/roles' % self._path)
Reference to the service that manages the collection of roles assigned to this system group.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'roles': return self.roles_service() if path.startswith('roles/'): return self.roles_service().service(path[6:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class GroupsService(Service): """ Manages the collection of groups of users. """ def __init__(self, connection, path): super(GroupsService, self).__init__(connection, path) self._group_service = None def add( self, group, headers=None, query=None, wait=True, **kwargs ): """ Add group from a directory service. Please note that domain name is name of the authorization provider. For example, to add the `Developers` group from the `internal-authz` authorization provider send a request like this: [source] ---- POST /ovirt-engine/api/groups ---- With a request body like this: [source,xml] ---- <group> <name>Developers</name> <domain> <name>internal-authz</name> </domain> </group> ---- This method supports the following parameters: `group`:: The group to be added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('group', group, types.Group), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(group, headers, query, wait) def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ List all the groups in the system. Usage: .... GET /ovirt-engine/api/groups .... Will return the list of groups: [source,xml] ---- <groups> <group href="/ovirt-engine/api/groups/123" id="123"> <name>mygroup</name> <link href="/ovirt-engine/api/groups/123/roles" rel="roles"/> <link href="/ovirt-engine/api/groups/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/groups/123/tags" rel="tags"/> <domain_entry_id>476652557A382F67696B6D2B32762B37796E46476D513D3D</domain_entry_id> <namespace>DC=example,DC=com</namespace> <domain href="/ovirt-engine/api/domains/ABCDEF" id="ABCDEF"> <name>myextension-authz</name> </domain> </group> ... </groups> ---- The order of the returned list of groups isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of groups to return. If not specified all the groups are returned. `search`:: A query string used to restrict the returned groups. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def group_service(self, id): """ Reference to the service that manages a specific group. """ Service._check_types([ ('id', id, str), ]) return GroupService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.group_service(path) return self.group_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'GroupsService:%s' % self._path
Manages the collection of groups of users.
View Source
def __init__(self, connection, path): super(GroupsService, self).__init__(connection, path) self._group_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, group, headers=None, query=None, wait=True, **kwargs ): """ Add group from a directory service. Please note that domain name is name of the authorization provider. For example, to add the `Developers` group from the `internal-authz` authorization provider send a request like this: [source] ---- POST /ovirt-engine/api/groups ---- With a request body like this: [source,xml] ---- <group> <name>Developers</name> <domain> <name>internal-authz</name> </domain> </group> ---- This method supports the following parameters: `group`:: The group to be added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('group', group, types.Group), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(group, headers, query, wait)
Add group from a directory service. Please note that domain name is name of the authorization provider.
For example, to add the Developers group from the internal-authz authorization provider send a request
like this:
[source]
POST /ovirt-engine/api/groups
With a request body like this:
[source,xml]
This method supports the following parameters:
group:: The group to be added.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
list(
self,
case_sensitive=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ List all the groups in the system. Usage: .... GET /ovirt-engine/api/groups .... Will return the list of groups: [source,xml] ---- <groups> <group href="/ovirt-engine/api/groups/123" id="123"> <name>mygroup</name> <link href="/ovirt-engine/api/groups/123/roles" rel="roles"/> <link href="/ovirt-engine/api/groups/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/groups/123/tags" rel="tags"/> <domain_entry_id>476652557A382F67696B6D2B32762B37796E46476D513D3D</domain_entry_id> <namespace>DC=example,DC=com</namespace> <domain href="/ovirt-engine/api/domains/ABCDEF" id="ABCDEF"> <name>myextension-authz</name> </domain> </group> ... </groups> ---- The order of the returned list of groups isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of groups to return. If not specified all the groups are returned. `search`:: A query string used to restrict the returned groups. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List all the groups in the system. Usage: .... GET /ovirt-engine/api/groups .... Will return the list of groups:
[source,xml]
The order of the returned list of groups isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of groups to return. If not specified all the groups are returned.
search:: A query string used to restrict the returned groups.
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def group_service(self, id): """ Reference to the service that manages a specific group. """ Service._check_types([ ('id', id, str), ]) return GroupService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages a specific group.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.group_service(path) return self.group_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class HostDeviceService(Service): """ A service to access a particular device of a host. """ def __init__(self, connection, path): super(HostDeviceService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieve information about a particular host's device. An example of getting a host device: [source] ---- GET /ovirt-engine/api/hosts/123/devices/456 ---- [source,xml] ---- <host_device href="/ovirt-engine/api/hosts/123/devices/456" id="456"> <name>usb_1_9_1_1_0</name> <capability>usb</capability> <host href="/ovirt-engine/api/hosts/123" id="123"/> <parent_device href="/ovirt-engine/api/hosts/123/devices/789" id="789"> <name>usb_1_9_1</name> </parent_device> </host_device> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'HostDeviceService:%s' % self._path
A service to access a particular device of a host.
View Source
def __init__(self, connection, path): super(HostDeviceService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieve information about a particular host's device. An example of getting a host device: [source] ---- GET /ovirt-engine/api/hosts/123/devices/456 ---- [source,xml] ---- <host_device href="/ovirt-engine/api/hosts/123/devices/456" id="456"> <name>usb_1_9_1_1_0</name> <capability>usb</capability> <host href="/ovirt-engine/api/hosts/123" id="123"/> <parent_device href="/ovirt-engine/api/hosts/123/devices/789" id="789"> <name>usb_1_9_1</name> </parent_device> </host_device> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieve information about a particular host's device. An example of getting a host device:
[source]
GET /ovirt-engine/api/hosts/123/devices/456
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class HostDevicesService(Service): """ A service to access host devices. """ def __init__(self, connection, path): super(HostDevicesService, self).__init__(connection, path) self._device_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the devices of a host. The order of the returned list of devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of devices to return. If not specified all the devices are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def device_service(self, id): """ Reference to the service that can be used to access a specific host device. """ Service._check_types([ ('id', id, str), ]) return HostDeviceService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.device_service(path) return self.device_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'HostDevicesService:%s' % self._path
A service to access host devices.
View Source
def __init__(self, connection, path): super(HostDevicesService, self).__init__(connection, path) self._device_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the devices of a host. The order of the returned list of devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of devices to return. If not specified all the devices are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List the devices of a host. The order of the returned list of devices isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of devices to return. If not specified all the devices are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def device_service(self, id): """ Reference to the service that can be used to access a specific host device. """ Service._check_types([ ('id', id, str), ]) return HostDeviceService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that can be used to access a specific host device.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.device_service(path) return self.device_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class HostHookService(Service): """ """ def __init__(self, connection, path): super(HostHookService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'HostHookService:%s' % self._path
View Source
def __init__(self, connection, path): super(HostHookService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class HostHooksService(Service): """ """ def __init__(self, connection, path): super(HostHooksService, self).__init__(connection, path) self._hook_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of hooks configured for the host. The order of the returned list of hooks is random. This method supports the following parameters: `max`:: Sets the maximum number of hooks to return. If not specified, all the hooks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def hook_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return HostHookService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.hook_service(path) return self.hook_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'HostHooksService:%s' % self._path
View Source
def __init__(self, connection, path): super(HostHooksService, self).__init__(connection, path) self._hook_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of hooks configured for the host. The order of the returned list of hooks is random. This method supports the following parameters: `max`:: Sets the maximum number of hooks to return. If not specified, all the hooks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of hooks configured for the host. The order of the returned list of hooks is random.
This method supports the following parameters:
max:: Sets the maximum number of hooks to return. If not specified, all the hooks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def hook_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return HostHookService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.hook_service(path) return self.hook_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class HostNicsService(Service): """ A service to manage the network interfaces of a host. """ def __init__(self, connection, path): super(HostNicsService, self).__init__(connection, path) self._nic_service = None def list( self, all_content=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of network interfaces of the host. The order of the returned list of network interfaces isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `all_content`:: Indicates if all of the attributes of the host network interface should be included in the response. By default the following attributes are excluded: - `virtual_functions_configuration` For example, to retrieve the complete representation of network interface '456' of host '123': .... GET /ovirt-engine/api/hosts/123/nics?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. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def nic_service(self, id): """ Reference to the service that manages a single network interface. """ Service._check_types([ ('id', id, str), ]) return HostNicService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'HostNicsService:%s' % self._path
A service to manage the network interfaces of a host.
View Source
def __init__(self, connection, path): super(HostNicsService, self).__init__(connection, path) self._nic_service = None
Creates a new service that will use the given connection and path.
#
def
list(
self,
all_content=None,
follow=None,
max=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, all_content=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of network interfaces of the host. The order of the returned list of network interfaces isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `all_content`:: Indicates if all of the attributes of the host network interface should be included in the response. By default the following attributes are excluded: - `virtual_functions_configuration` For example, to retrieve the complete representation of network interface '456' of host '123': .... GET /ovirt-engine/api/hosts/123/nics?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. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of network interfaces of the host. The order of the returned list of network interfaces isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of NICs to return. If not specified all the NICs are returned.
all_content:: Indicates if all of the attributes of the host network interface should be included in the response.
By default the following attributes are excluded:
virtual_functions_configurationFor example, to retrieve the complete representation of network interface '456' of host '123': .... GET /ovirt-engine/api/hosts/123/nics?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.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def nic_service(self, id): """ Reference to the service that manages a single network interface. """ Service._check_types([ ('id', id, str), ]) return HostNicService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages a single network interface.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class HostNumaNodesService(Service): """ """ def __init__(self, connection, path): super(HostNumaNodesService, self).__init__(connection, path) self._node_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of NUMA nodes of the host. The order of the returned list of NUMA nodes isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of nodes to return. If not specified all the nodes are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def node_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return HostNumaNodeService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.node_service(path) return self.node_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'HostNumaNodesService:%s' % self._path
View Source
def __init__(self, connection, path): super(HostNumaNodesService, self).__init__(connection, path) self._node_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of NUMA nodes of the host. The order of the returned list of NUMA nodes isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of nodes to return. If not specified all the nodes are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of NUMA nodes of the host. The order of the returned list of NUMA nodes isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of nodes to return. If not specified all the nodes are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def node_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return HostNumaNodeService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.node_service(path) return self.node_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class HostStorageService(Service): """ A service to manage host storages. """ def __init__(self, connection, path): super(HostStorageService, self).__init__(connection, path) self._storage_service = None def list( self, follow=None, report_status=None, headers=None, query=None, wait=True, **kwargs ): """ Get list of storages. [source] ---- GET /ovirt-engine/api/hosts/123/storage ---- The XML response you get will be like this one: [source,xml] ---- <host_storages> <host_storage id="123"> ... </host_storage> ... </host_storages> ---- The order of the returned list of storages isn't guaranteed. This method supports the following parameters: `report_status`:: Indicates if the status of the LUNs in the storage should be checked. Checking the status of the LUN is an heavy weight operation and this data is not always needed by the user. This parameter will give the option to not perform the status check of the LUNs. The default is `true` for backward compatibility. Here an example with the LUN status : [source,xml] ---- <host_storage id="123"> <logical_units> <logical_unit id="123"> <lun_mapping>0</lun_mapping> <paths>1</paths> <product_id>lun0</product_id> <serial>123</serial> <size>10737418240</size> <status>used</status> <vendor_id>LIO-ORG</vendor_id> <volume_group_id>123</volume_group_id> </logical_unit> </logical_units> <type>iscsi</type> <host id="123"/> </host_storage> ---- Here an example without the LUN status : [source,xml] ---- <host_storage id="123"> <logical_units> <logical_unit id="123"> <lun_mapping>0</lun_mapping> <paths>1</paths> <product_id>lun0</product_id> <serial>123</serial> <size>10737418240</size> <vendor_id>LIO-ORG</vendor_id> <volume_group_id>123</volume_group_id> </logical_unit> </logical_units> <type>iscsi</type> <host id="123"/> </host_storage> ---- `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('report_status', report_status, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if report_status is not None: report_status = Writer.render_boolean(report_status) query['report_status'] = report_status # Send the request and wait for the response: return self._internal_get(headers, query, wait) def storage_service(self, id): """ Reference to a service managing the storage. """ Service._check_types([ ('id', id, str), ]) return StorageService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_service(path) return self.storage_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'HostStorageService:%s' % self._path
A service to manage host storages.
View Source
def __init__(self, connection, path): super(HostStorageService, self).__init__(connection, path) self._storage_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, report_status=None, headers=None, query=None, wait=True, **kwargs ): """ Get list of storages. [source] ---- GET /ovirt-engine/api/hosts/123/storage ---- The XML response you get will be like this one: [source,xml] ---- <host_storages> <host_storage id="123"> ... </host_storage> ... </host_storages> ---- The order of the returned list of storages isn't guaranteed. This method supports the following parameters: `report_status`:: Indicates if the status of the LUNs in the storage should be checked. Checking the status of the LUN is an heavy weight operation and this data is not always needed by the user. This parameter will give the option to not perform the status check of the LUNs. The default is `true` for backward compatibility. Here an example with the LUN status : [source,xml] ---- <host_storage id="123"> <logical_units> <logical_unit id="123"> <lun_mapping>0</lun_mapping> <paths>1</paths> <product_id>lun0</product_id> <serial>123</serial> <size>10737418240</size> <status>used</status> <vendor_id>LIO-ORG</vendor_id> <volume_group_id>123</volume_group_id> </logical_unit> </logical_units> <type>iscsi</type> <host id="123"/> </host_storage> ---- Here an example without the LUN status : [source,xml] ---- <host_storage id="123"> <logical_units> <logical_unit id="123"> <lun_mapping>0</lun_mapping> <paths>1</paths> <product_id>lun0</product_id> <serial>123</serial> <size>10737418240</size> <vendor_id>LIO-ORG</vendor_id> <volume_group_id>123</volume_group_id> </logical_unit> </logical_units> <type>iscsi</type> <host id="123"/> </host_storage> ---- `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('report_status', report_status, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if report_status is not None: report_status = Writer.render_boolean(report_status) query['report_status'] = report_status # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get list of storages.
[source]
GET /ovirt-engine/api/hosts/123/storage
The XML response you get will be like this one:
[source,xml]
The order of the returned list of storages isn't guaranteed.
This method supports the following parameters:
report_status:: Indicates if the status of the LUNs in the storage should be checked.
Checking the status of the LUN is an heavy weight operation and
this data is not always needed by the user.
This parameter will give the option to not perform the status check of the LUNs.
The default is true for backward compatibility.
Here an example with the LUN status :
[source,xml]
Here an example without the LUN status :
[source,xml]
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def storage_service(self, id): """ Reference to a service managing the storage. """ Service._check_types([ ('id', id, str), ]) return StorageService(self._connection, '%s/%s' % (self._path, id))
Reference to a service managing the storage.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_service(path) return self.storage_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class HostsService(Service): """ A service that manages hosts. """ def __init__(self, connection, path): super(HostsService, self).__init__(connection, path) self._host_service = None def add( self, host, activate=None, deploy_hosted_engine=None, reboot=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ Creates a new host. The host is created based on the attributes of the `host` parameter. The `name`, `address`, and `root_password` properties are required. For example, to add a host, send the following request: [source] ---- POST /ovirt-engine/api/hosts ---- With the following request body: [source,xml] ---- <host> <name>myhost</name> <address>myhost.example.com</address> <root_password>myrootpassword</root_password> </host> ---- NOTE: The `root_password` element is only included in the client-provided initial representation and is not exposed in the representations returned from subsequent requests. IMPORTANT: Since version 4.1.2 of the engine, when a host is newly added, the host's firewall definitions are overridden by default. To add a hosted engine host, use the optional `deploy_hosted_engine` parameter: [source] ---- POST /ovirt-engine/api/hosts?deploy_hosted_engine=true ---- If the cluster has a default external network provider that is supported for automatic deployment, the external network provider is deployed when adding the host. Only external network providers for OVN are supported for the automatic deployment. To deploy an external network provider other than the one defined in the clusters, overwrite the external network provider when adding hosts, by sending the following request: [source] ---- POST /ovirt-engine/api/hosts ---- With a request body that contains a reference to the desired provider in the `external_network_provider_configuration`: [source,xml] ---- <host> <name>myhost</name> <address>myhost.example.com</address> <root_password>123456</root_password> <external_network_provider_configurations> <external_network_provider_configuration> <external_network_provider name="ovirt-provider-ovn"/> </external_network_provider_configuration> </external_network_provider_configurations> </host> ---- This method supports the following parameters: `host`:: The host definition with which the new host is created is passed as a parameter, and the newly created host is returned. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('activate', activate, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('reboot', reboot, bool), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Build the URL: query = query or {} if activate is not None: activate = Writer.render_boolean(activate) query['activate'] = activate if deploy_hosted_engine is not None: deploy_hosted_engine = Writer.render_boolean(deploy_hosted_engine) query['deploy_hosted_engine'] = deploy_hosted_engine if reboot is not None: reboot = Writer.render_boolean(reboot) query['reboot'] = reboot if undeploy_hosted_engine is not None: undeploy_hosted_engine = Writer.render_boolean(undeploy_hosted_engine) query['undeploy_hosted_engine'] = undeploy_hosted_engine # Send the request and wait for the response: return self._internal_add(host, headers, query, wait) def list( self, all_content=None, case_sensitive=None, check_vms_in_affinity_closure=None, filter=None, follow=None, max=None, migration_target_of=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Get a list of all available hosts. For example, to list the hosts send the following request: .... GET /ovirt-engine/api/hosts .... The response body will be similar to this: [source,xml] ---- <hosts> <host href="/ovirt-engine/api/hosts/123" id="123"> ... </host> <host href="/ovirt-engine/api/hosts/456" id="456"> ... </host> ... </host> ---- The order of the returned list of hosts is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of hosts to return. If not specified all the hosts are returned. `search`:: A query string used to restrict the returned hosts. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `all_content`:: Indicates if all of the attributes of the hosts should be included in the response. By default the following host attributes are excluded: - `hosted_engine` For example, to retrieve the complete representation of the hosts: .... GET /ovirt-engine/api/hosts?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. `migration_target_of`:: Accepts a comma-separated list of virtual machine IDs and returns the hosts that these virtual machines can be migrated to. For example, to retrieve the list of hosts to which the virtual machine with ID 123 and the virtual machine with ID 456 can be migrated to, send the following request: .... GET /ovirt-engine/api/hosts?migration_target_of=123,456 .... `check_vms_in_affinity_closure`:: This parameter can be used with `migration_target_of` to get valid migration targets for the listed virtual machines and all other virtual machines that are in positive enforcing affinity with the listed virtual machines. This is useful in case the virtual machines will be migrated together with others in positive affinity groups. The default value is `false`. .... GET /ovirt-engine/api/hosts?migration_target_of=123,456&check_vms_in_affinity_closure=true .... `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('case_sensitive', case_sensitive, bool), ('check_vms_in_affinity_closure', check_vms_in_affinity_closure, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('migration_target_of', migration_target_of, str), ('search', search, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if check_vms_in_affinity_closure is not None: check_vms_in_affinity_closure = Writer.render_boolean(check_vms_in_affinity_closure) query['check_vms_in_affinity_closure'] = check_vms_in_affinity_closure if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if migration_target_of is not None: query['migration_target_of'] = migration_target_of if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def add_using_root_password( self, host, activate=None, deploy_hosted_engine=None, reboot=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ Add a new host to the system providing the host root password. This has been deprecated and provided for backwards compatibility. This method supports the following parameters: `host`:: The host definition with which the new host is created is passed as a parameter, and the newly created host is returned. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('activate', activate, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('reboot', reboot, bool), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Build the URL: query = query or {} if activate is not None: activate = Writer.render_boolean(activate) query['activate'] = activate if deploy_hosted_engine is not None: deploy_hosted_engine = Writer.render_boolean(deploy_hosted_engine) query['deploy_hosted_engine'] = deploy_hosted_engine if reboot is not None: reboot = Writer.render_boolean(reboot) query['reboot'] = reboot if undeploy_hosted_engine is not None: undeploy_hosted_engine = Writer.render_boolean(undeploy_hosted_engine) query['undeploy_hosted_engine'] = undeploy_hosted_engine # Send the request and wait for the response: return self._internal_add(host, headers, query, wait) def add_using_ssh( self, host, activate=None, deploy_hosted_engine=None, reboot=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ Add a new host to the system providing the ssh password, fingerprint or public key. This method supports the following parameters: `host`:: The host definition with which the new host is created is passed as a parameter, and the newly created host is returned. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('activate', activate, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('reboot', reboot, bool), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Build the URL: query = query or {} if activate is not None: activate = Writer.render_boolean(activate) query['activate'] = activate if deploy_hosted_engine is not None: deploy_hosted_engine = Writer.render_boolean(deploy_hosted_engine) query['deploy_hosted_engine'] = deploy_hosted_engine if reboot is not None: reboot = Writer.render_boolean(reboot) query['reboot'] = reboot if undeploy_hosted_engine is not None: undeploy_hosted_engine = Writer.render_boolean(undeploy_hosted_engine) query['undeploy_hosted_engine'] = undeploy_hosted_engine # Send the request and wait for the response: return self._internal_add(host, headers, query, wait) def host_service(self, id): """ A Reference to service managing a specific host. """ Service._check_types([ ('id', id, str), ]) return HostService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'HostsService:%s' % self._path
A service that manages hosts.
View Source
def __init__(self, connection, path): super(HostsService, self).__init__(connection, path) self._host_service = None
Creates a new service that will use the given connection and path.
#
def
add(
self,
host,
activate=None,
deploy_hosted_engine=None,
reboot=None,
undeploy_hosted_engine=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def add( self, host, activate=None, deploy_hosted_engine=None, reboot=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ Creates a new host. The host is created based on the attributes of the `host` parameter. The `name`, `address`, and `root_password` properties are required. For example, to add a host, send the following request: [source] ---- POST /ovirt-engine/api/hosts ---- With the following request body: [source,xml] ---- <host> <name>myhost</name> <address>myhost.example.com</address> <root_password>myrootpassword</root_password> </host> ---- NOTE: The `root_password` element is only included in the client-provided initial representation and is not exposed in the representations returned from subsequent requests. IMPORTANT: Since version 4.1.2 of the engine, when a host is newly added, the host's firewall definitions are overridden by default. To add a hosted engine host, use the optional `deploy_hosted_engine` parameter: [source] ---- POST /ovirt-engine/api/hosts?deploy_hosted_engine=true ---- If the cluster has a default external network provider that is supported for automatic deployment, the external network provider is deployed when adding the host. Only external network providers for OVN are supported for the automatic deployment. To deploy an external network provider other than the one defined in the clusters, overwrite the external network provider when adding hosts, by sending the following request: [source] ---- POST /ovirt-engine/api/hosts ---- With a request body that contains a reference to the desired provider in the `external_network_provider_configuration`: [source,xml] ---- <host> <name>myhost</name> <address>myhost.example.com</address> <root_password>123456</root_password> <external_network_provider_configurations> <external_network_provider_configuration> <external_network_provider name="ovirt-provider-ovn"/> </external_network_provider_configuration> </external_network_provider_configurations> </host> ---- This method supports the following parameters: `host`:: The host definition with which the new host is created is passed as a parameter, and the newly created host is returned. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('activate', activate, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('reboot', reboot, bool), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Build the URL: query = query or {} if activate is not None: activate = Writer.render_boolean(activate) query['activate'] = activate if deploy_hosted_engine is not None: deploy_hosted_engine = Writer.render_boolean(deploy_hosted_engine) query['deploy_hosted_engine'] = deploy_hosted_engine if reboot is not None: reboot = Writer.render_boolean(reboot) query['reboot'] = reboot if undeploy_hosted_engine is not None: undeploy_hosted_engine = Writer.render_boolean(undeploy_hosted_engine) query['undeploy_hosted_engine'] = undeploy_hosted_engine # Send the request and wait for the response: return self._internal_add(host, headers, query, wait)
Creates a new host.
The host is created based on the attributes of the host parameter. The name, address, and root_password
properties are required.
For example, to add a host, send the following request:
[source]
POST /ovirt-engine/api/hosts
With the following request body:
[source,xml]
NOTE: The root_password element is only included in the client-provided initial representation and is not
exposed in the representations returned from subsequent requests.
IMPORTANT: Since version 4.1.2 of the engine, when a host is newly added, the host's firewall
definitions are overridden by default.
To add a hosted engine host, use the optional deploy_hosted_engine parameter:
[source]
POST /ovirt-engine/api/hosts?deploy_hosted_engine=true
If the cluster has a default external network provider that is supported for automatic deployment, the external network provider is deployed when adding the host. Only external network providers for OVN are supported for the automatic deployment. To deploy an external network provider other than the one defined in the clusters, overwrite the external network provider when adding hosts, by sending the following request:
[source]
POST /ovirt-engine/api/hosts
With a request body that contains a reference to the desired provider in the
external_network_provider_configuration:
[source,xml]
This method supports the following parameters:
host:: The host definition with which the new host is created is passed as a parameter, and the newly created host
is returned.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
list(
self,
all_content=None,
case_sensitive=None,
check_vms_in_affinity_closure=None,
filter=None,
follow=None,
max=None,
migration_target_of=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, all_content=None, case_sensitive=None, check_vms_in_affinity_closure=None, filter=None, follow=None, max=None, migration_target_of=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Get a list of all available hosts. For example, to list the hosts send the following request: .... GET /ovirt-engine/api/hosts .... The response body will be similar to this: [source,xml] ---- <hosts> <host href="/ovirt-engine/api/hosts/123" id="123"> ... </host> <host href="/ovirt-engine/api/hosts/456" id="456"> ... </host> ... </host> ---- The order of the returned list of hosts is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of hosts to return. If not specified all the hosts are returned. `search`:: A query string used to restrict the returned hosts. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `all_content`:: Indicates if all of the attributes of the hosts should be included in the response. By default the following host attributes are excluded: - `hosted_engine` For example, to retrieve the complete representation of the hosts: .... GET /ovirt-engine/api/hosts?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. `migration_target_of`:: Accepts a comma-separated list of virtual machine IDs and returns the hosts that these virtual machines can be migrated to. For example, to retrieve the list of hosts to which the virtual machine with ID 123 and the virtual machine with ID 456 can be migrated to, send the following request: .... GET /ovirt-engine/api/hosts?migration_target_of=123,456 .... `check_vms_in_affinity_closure`:: This parameter can be used with `migration_target_of` to get valid migration targets for the listed virtual machines and all other virtual machines that are in positive enforcing affinity with the listed virtual machines. This is useful in case the virtual machines will be migrated together with others in positive affinity groups. The default value is `false`. .... GET /ovirt-engine/api/hosts?migration_target_of=123,456&check_vms_in_affinity_closure=true .... `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('case_sensitive', case_sensitive, bool), ('check_vms_in_affinity_closure', check_vms_in_affinity_closure, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('migration_target_of', migration_target_of, str), ('search', search, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if check_vms_in_affinity_closure is not None: check_vms_in_affinity_closure = Writer.render_boolean(check_vms_in_affinity_closure) query['check_vms_in_affinity_closure'] = check_vms_in_affinity_closure if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if migration_target_of is not None: query['migration_target_of'] = migration_target_of if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get a list of all available hosts. For example, to list the hosts send the following request: .... GET /ovirt-engine/api/hosts .... The response body will be similar to this:
[source,xml]
The order of the returned list of hosts is guaranteed only if the sortby clause is included in
the search parameter.
This method supports the following parameters:
max:: Sets the maximum number of hosts to return. If not specified all the hosts are returned.
search:: A query string used to restrict the returned hosts.
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
filter:: Indicates if the results should be filtered according to the permissions of the user.
all_content:: Indicates if all of the attributes of the hosts should be included in the response.
By default the following host attributes are excluded:
hosted_engineFor example, to retrieve the complete representation of the hosts: .... GET /ovirt-engine/api/hosts?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.
migration_target_of:: Accepts a comma-separated list of virtual machine IDs and returns the hosts
that these virtual machines can be migrated to.
For example, to retrieve the list of hosts to which the virtual machine with ID 123 and
the virtual machine with ID 456 can be migrated to, send the following request:
....
GET /ovirt-engine/api/hosts?migration_target_of=123,456
....
check_vms_in_affinity_closure:: This parameter can be used with migration_target_of
to get valid migration targets for the listed virtual machines
and all other virtual machines that are in positive enforcing
affinity with the listed virtual machines.
This is useful in case the virtual machines will be migrated
together with others in positive affinity groups.
The default value is false.
....
GET /ovirt-engine/api/hosts?migration_target_of=123,456&check_vms_in_affinity_closure=true
....
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
add_using_root_password(
self,
host,
activate=None,
deploy_hosted_engine=None,
reboot=None,
undeploy_hosted_engine=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def add_using_root_password( self, host, activate=None, deploy_hosted_engine=None, reboot=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ Add a new host to the system providing the host root password. This has been deprecated and provided for backwards compatibility. This method supports the following parameters: `host`:: The host definition with which the new host is created is passed as a parameter, and the newly created host is returned. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('activate', activate, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('reboot', reboot, bool), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Build the URL: query = query or {} if activate is not None: activate = Writer.render_boolean(activate) query['activate'] = activate if deploy_hosted_engine is not None: deploy_hosted_engine = Writer.render_boolean(deploy_hosted_engine) query['deploy_hosted_engine'] = deploy_hosted_engine if reboot is not None: reboot = Writer.render_boolean(reboot) query['reboot'] = reboot if undeploy_hosted_engine is not None: undeploy_hosted_engine = Writer.render_boolean(undeploy_hosted_engine) query['undeploy_hosted_engine'] = undeploy_hosted_engine # Send the request and wait for the response: return self._internal_add(host, headers, query, wait)
Add a new host to the system providing the host root password. This has been deprecated and provided for backwards compatibility.
This method supports the following parameters:
host:: The host definition with which the new host is created is passed as a parameter, and the newly created host
is returned.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
add_using_ssh(
self,
host,
activate=None,
deploy_hosted_engine=None,
reboot=None,
undeploy_hosted_engine=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def add_using_ssh( self, host, activate=None, deploy_hosted_engine=None, reboot=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ Add a new host to the system providing the ssh password, fingerprint or public key. This method supports the following parameters: `host`:: The host definition with which the new host is created is passed as a parameter, and the newly created host is returned. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('activate', activate, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('reboot', reboot, bool), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Build the URL: query = query or {} if activate is not None: activate = Writer.render_boolean(activate) query['activate'] = activate if deploy_hosted_engine is not None: deploy_hosted_engine = Writer.render_boolean(deploy_hosted_engine) query['deploy_hosted_engine'] = deploy_hosted_engine if reboot is not None: reboot = Writer.render_boolean(reboot) query['reboot'] = reboot if undeploy_hosted_engine is not None: undeploy_hosted_engine = Writer.render_boolean(undeploy_hosted_engine) query['undeploy_hosted_engine'] = undeploy_hosted_engine # Send the request and wait for the response: return self._internal_add(host, headers, query, wait)
Add a new host to the system providing the ssh password, fingerprint or public key.
This method supports the following parameters:
host:: The host definition with which the new host is created is passed as a parameter, and the newly created host
is returned.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def host_service(self, id): """ A Reference to service managing a specific host. """ Service._check_types([ ('id', id, str), ]) return HostService(self._connection, '%s/%s' % (self._path, id))
A Reference to service managing a specific host.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.host_service(path) return self.host_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class IconService(Service): """ A service to manage an icon (read-only). """ def __init__(self, connection, path): super(IconService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get an icon. [source] ---- GET /ovirt-engine/api/icons/123 ---- You will get a XML response like this one: [source,xml] ---- <icon id="123"> <data>Some binary data here</data> <media_type>image/png</media_type> </icon> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'IconService:%s' % self._path
A service to manage an icon (read-only).
View Source
def __init__(self, connection, path): super(IconService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get an icon. [source] ---- GET /ovirt-engine/api/icons/123 ---- You will get a XML response like this one: [source,xml] ---- <icon id="123"> <data>Some binary data here</data> <media_type>image/png</media_type> </icon> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get an icon.
[source]
GET /ovirt-engine/api/icons/123
You will get a XML response like this one:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class IconsService(Service): """ A service to manage icons. """ def __init__(self, connection, path): super(IconsService, self).__init__(connection, path) self._icon_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Get a list of icons. [source] ---- GET /ovirt-engine/api/icons ---- You will get a XML response which is similar to this one: [source,xml] ---- <icons> <icon id="123"> <data>...</data> <media_type>image/png</media_type> </icon> ... </icons> ---- The order of the returned list of icons isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of icons to return. If not specified all the icons are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def icon_service(self, id): """ Reference to the service that manages an specific icon. """ Service._check_types([ ('id', id, str), ]) return IconService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.icon_service(path) return self.icon_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'IconsService:%s' % self._path
A service to manage icons.
View Source
def __init__(self, connection, path): super(IconsService, self).__init__(connection, path) self._icon_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Get a list of icons. [source] ---- GET /ovirt-engine/api/icons ---- You will get a XML response which is similar to this one: [source,xml] ---- <icons> <icon id="123"> <data>...</data> <media_type>image/png</media_type> </icon> ... </icons> ---- The order of the returned list of icons isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of icons to return. If not specified all the icons are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get a list of icons.
[source]
GET /ovirt-engine/api/icons
You will get a XML response which is similar to this one:
[source,xml]
The order of the returned list of icons isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of icons to return. If not specified all the icons are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def icon_service(self, id): """ Reference to the service that manages an specific icon. """ Service._check_types([ ('id', id, str), ]) return IconService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages an specific icon.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.icon_service(path) return self.icon_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ImageService(Service): """ """ def __init__(self, connection, path): super(ImageService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_( self, async_=None, cluster=None, disk=None, import_as_template=None, storage_domain=None, template=None, headers=None, query=None, wait=True, **kwargs ): """ Imports an image. If the `import_as_template` parameter is `true` then the image will be imported as a template, otherwise it will be imported as a disk. When imported as a template, the name of the template can be specified by the optional `template.name` parameter. If that parameter is not specified, then the name of the template will be automatically assigned by the engine as `GlanceTemplate-x` (where `x` will be seven random hexadecimal characters). When imported as a disk, the name of the disk can be specified by the optional `disk.name` parameter. If that parameter is not specified, then the name of the disk will be automatically assigned by the engine as `GlanceDisk-x` (where `x` will be the seven hexadecimal characters of the image identifier). It is recommended to always explicitly specify the template or disk name, to avoid these automatic names generated by the engine. This method supports the following parameters: `cluster`:: The cluster to which the image should be imported if the `import_as_template` parameter is set to `true`. `disk`:: The disk to import. `import_as_template`:: Specifies if a template should be created from the imported disk. `template`:: The name of the template being created if the `import_as_template` parameter is set to `true`. `storage_domain`:: The storage domain to which the disk should be imported. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('disk', disk, types.Disk), ('import_as_template', import_as_template, bool), ('storage_domain', storage_domain, types.StorageDomain), ('template', template, types.Template), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, cluster=cluster, disk=disk, import_as_template=import_as_template, storage_domain=storage_domain, template=template, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ImageService:%s' % self._path
View Source
def __init__(self, connection, path): super(ImageService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
import_(
self,
async_=None,
cluster=None,
disk=None,
import_as_template=None,
storage_domain=None,
template=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def import_( self, async_=None, cluster=None, disk=None, import_as_template=None, storage_domain=None, template=None, headers=None, query=None, wait=True, **kwargs ): """ Imports an image. If the `import_as_template` parameter is `true` then the image will be imported as a template, otherwise it will be imported as a disk. When imported as a template, the name of the template can be specified by the optional `template.name` parameter. If that parameter is not specified, then the name of the template will be automatically assigned by the engine as `GlanceTemplate-x` (where `x` will be seven random hexadecimal characters). When imported as a disk, the name of the disk can be specified by the optional `disk.name` parameter. If that parameter is not specified, then the name of the disk will be automatically assigned by the engine as `GlanceDisk-x` (where `x` will be the seven hexadecimal characters of the image identifier). It is recommended to always explicitly specify the template or disk name, to avoid these automatic names generated by the engine. This method supports the following parameters: `cluster`:: The cluster to which the image should be imported if the `import_as_template` parameter is set to `true`. `disk`:: The disk to import. `import_as_template`:: Specifies if a template should be created from the imported disk. `template`:: The name of the template being created if the `import_as_template` parameter is set to `true`. `storage_domain`:: The storage domain to which the disk should be imported. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('disk', disk, types.Disk), ('import_as_template', import_as_template, bool), ('storage_domain', storage_domain, types.StorageDomain), ('template', template, types.Template), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, cluster=cluster, disk=disk, import_as_template=import_as_template, storage_domain=storage_domain, template=template, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait)
Imports an image.
If the import_as_template parameter is true then the image will be imported as a template, otherwise it will
be imported as a disk.
When imported as a template, the name of the template can be specified by the optional template.name
parameter. If that parameter is not specified, then the name of the template will be automatically assigned by the
engine as GlanceTemplate-x (where x will be seven random hexadecimal characters).
When imported as a disk, the name of the disk can be specified by the optional disk.name parameter. If
that parameter is not specified, then the name of the disk will be automatically assigned by the engine as
GlanceDisk-x (where x will be the seven hexadecimal characters of the image identifier).
It is recommended to always explicitly specify the template or disk name, to avoid these automatic names
generated by the engine.
This method supports the following parameters:
cluster:: The cluster to which the image should be imported if the import_as_template parameter
is set to true.
disk:: The disk to import.
import_as_template:: Specifies if a template should be created from the imported disk.
template:: The name of the template being created if the
import_as_template parameter is set to true.
storage_domain:: The storage domain to which the disk should be imported.
async_:: Indicates if the import should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ImageTransferService(Service): """ This service provides a mechanism to control an image transfer. The client will have to create a transfer by using <<services/image_transfers/methods/add, add>> of the <<services/image_transfers>> service, stating the image to transfer data to/from. After doing that, the transfer is managed by this service. *Using oVirt's Python's SDK:* Uploading a `disk` with id `123` (on a random host in the data center): [source,python] ---- transfers_service = system_service.image_transfers_service() transfer = transfers_service.add( types.ImageTransfer( disk=types.Disk( id='123' ) ) ) ---- Uploading a `disk` with id `123` on `host` id `456`: [source,python] ---- transfers_service = system_service.image_transfers_service() transfer = transfers_service.add( types.ImageTransfer( disk=types.Disk( id='123' ), host=types.Host( id='456' ) ) ) ---- If the user wishes to download a disk rather than upload, he/she should specify `download` as the <<types/image_transfer_direction, direction>> attribute of the transfer. This will grant a read permission from the image, instead of a write permission. E.g: [source,python] ---- transfers_service = system_service.image_transfers_service() transfer = transfers_service.add( types.ImageTransfer( disk=types.Disk( id='123' ), direction=types.ImageTransferDirection.DOWNLOAD ) ) ---- Transfers have phases, which govern the flow of the upload/download. A client implementing such a flow should poll/check the transfer's phase and act accordingly. All the possible phases can be found in <<types/image_transfer_phase, ImageTransferPhase>>. After adding a new transfer, its phase will be <<types/image_transfer_phase, initializing>>. The client will have to poll on the transfer's phase until it changes. When the phase becomes <<types/image_transfer_phase, transferring>>, the session is ready to start the transfer. For example: [source,python] ---- transfer_service = transfers_service.image_transfer_service(transfer.id) while transfer.phase == types.ImageTransferPhase.INITIALIZING: time.sleep(3) transfer = transfer_service.get() ---- At that stage, if the transfer's phase is <<types/image_transfer_phase, paused_system>>, then the session was not successfully established. One possible reason for that is that the ovirt-imageio-daemon is not running in the host that was selected for transfer. The transfer can be resumed by calling <<services/image_transfer/methods/resume, resume>> of the service that manages it. If the session was successfully established - the returned transfer entity will contain the <<types/image_transfer, transfer_url>> and <<types/image_transfer, proxy_url>> attributes, which the client needs to use in order to transfer the required data. The client can choose whatever technique and tool for sending the HTTPS request with the image's data. - `transfer_url` is the address of an imageio server running on one of the hypervisors. - `proxy_url` is the address of an imageio proxy server that can be used if you cannot access transfer_url. To transfer the image, it is recommended to use the imageio client python library. [source,python] ---- from ovirt_imageio import client # Upload qcow2 image to virtual disk: client.upload("disk.qcow2", transfer.transfer_url) # Download virtual disk to qcow2 image: client.download(transfer.transfer_url, "disk.qcow2") ---- You can also upload and download using imageio REST API. For more info on this, see imageio API documentation: http://ovirt.github.io/ovirt-imageio/images.html When finishing the transfer, the user should call <<services/image_transfer/methods/finalize, finalize>>. This will make the final adjustments and verifications for finishing the transfer process. For example: [source,python] ---- transfer_service.finalize() ---- In case of an error, the transfer's phase will be changed to <<types/image_transfer_phase, finished_failure>>, and the disk's status will be changed to `Illegal`. Otherwise it will be changed to <<types/image_transfer_phase, finished_success>>, and the disk will be ready to be used. In both cases, the transfer entity will be removed shortly after. *Using HTTP and cURL calls:* - For upload, create a new disk first: * Specify 'initial_size' and 'provisioned_size' in bytes. * 'initial_size' must be bigger or the same as the size of the uploaded data. [source] ---- POST /ovirt-engine/api/disks ---- With a request body as follows: [source,xml] ---- <disk> <storage_domains> <storage_domain id="123"/> </storage_domains> <alias>mydisk</alias> <initial_size>1073741824</initial_size> <provisioned_size>1073741824</provisioned_size> <format>raw</format> </disk> ---- - Create a new image transfer for downloading/uploading a `disk` with id `456`: [source] ---- POST /ovirt-engine/api/imagetransfers ---- With a request body as follows: [source,xml] ---- <image_transfer> <disk id="456"/> <direction>upload|download</direction> </image_transfer> ---- Will respond: [source,xml] ---- <image_transfer id="123"> <direction>download|upload</direction> <phase>initializing|transferring</phase> <proxy_url>https://proxy_fqdn:54323/images/41c732d4-2210-4e7b-9e5c-4e2805baadbb</proxy_url> <transfer_url>https://daemon_fqdn:54322/images/41c732d4-2210-4e7b-9e5c-4e2805baadbb</transfer_url> ... </image_transfer> ---- Note: If the phase is 'initializing', poll the `image_transfer` till its phase changes to 'transferring'. - Use the 'transfer_url' or 'proxy_url' to invoke a curl command: - use 'transfer_url' for transferring directly from/to ovirt-imageio-daemon, or, use 'proxy_url' for transferring from/to ovirt-imageio-proxy. Note: using the proxy would mitigate scenarios where there's no direct connectivity to the daemon machine, e.g. vdsm machines are on a different network than the engine. -- Download: [source,shell] ---- $ curl --cacert /etc/pki/ovirt-engine/ca.pem https://daemon_fqdn:54322/images/41c732d4-2210-4e7b-9e5c-4e2805baadbb -o <output_file> ---- -- Upload: [source,shell] ---- $ curl --cacert /etc/pki/ovirt-engine/ca.pem --upload-file <file_to_upload> -X PUT https://daemon_fqdn:54322/images/41c732d4-2210-4e7b-9e5c-4e2805baadbb ---- - Finalize the image transfer by invoking the action: [source] ---- POST /ovirt-engine/api/imagetransfers/123/finalize ---- With a request body as follows: [source,xml] ---- <action /> ---- """ def __init__(self, connection, path): super(ImageTransferService, self).__init__(connection, path) def cancel( self, headers=None, query=None, wait=True, **kwargs ): """ Cancel the image transfer session. This terminates the transfer operation and removes the partial image. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'cancel', None, headers, query, wait) def extend( self, headers=None, query=None, wait=True, **kwargs ): """ Extend the image transfer session. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'extend', None, headers, query, wait) def finalize( self, headers=None, query=None, wait=True, **kwargs ): """ After finishing to transfer the data, finalize the transfer. This will make sure that the data being transferred is valid and fits the image entity that was targeted in the transfer. Specifically, will verify that if the image entity is a QCOW disk, the data uploaded is indeed a QCOW file, and that the image doesn't have a backing file. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'finalize', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get the image transfer entity. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def pause( self, headers=None, query=None, wait=True, **kwargs ): """ Pause the image transfer session. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'pause', None, headers, query, wait) def resume( self, headers=None, query=None, wait=True, **kwargs ): """ Resume the image transfer session. The client will need to poll the transfer's phase until it is different than `resuming`. For example: [source,python] ---- transfer_service = transfers_service.image_transfer_service(transfer.id) transfer_service.resume() transfer = transfer_service.get() while transfer.phase == types.ImageTransferPhase.RESUMING: time.sleep(1) transfer = transfer_service.get() ---- """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'resume', None, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ImageTransferService:%s' % self._path
This service provides a mechanism to control an image transfer. The client will have
to create a transfer by using <disk with id 123 (on a random host in the data center):
[source,python]
transfers_service = system_service.image_transfers_service() transfer = transfers_service.add( types.ImageTransfer( disk=types.Disk( id='123' ) )
)
Uploading a disk with id 123 on host id 456:
[source,python]
transfers_service = system_service.image_transfers_service() transfer = transfers_service.add( types.ImageTransfer( disk=types.Disk( id='123' ), host=types.Host( id='456' ) )
)
If the user wishes to download a disk rather than upload, he/she should specify
download as the <
[source,python]
transfers_service = system_service.image_transfers_service() transfer = transfers_service.add( types.ImageTransfer( disk=types.Disk( id='123' ), direction=types.ImageTransferDirection.DOWNLOAD )
)
Transfers have phases, which govern the flow of the upload/download.
A client implementing such a flow should poll/check the transfer's phase and
act accordingly. All the possible phases can be found in
<
[source,python]
transfer_service = transfers_service.image_transfer_service(transfer.id) while transfer.phase == types.ImageTransferPhase.INITIALIZING: time.sleep(3)
transfer = transfer_service.get()
At that stage, if the transfer's phase is <
transfer_urlis the address of an imageio server running on one of the hypervisors.proxy_urlis the address of an imageio proxy server that can be used if you cannot access transfer_url. To transfer the image, it is recommended to use the imageio client python library.
[source,python]
from ovirt_imageio import client
Upload qcow2 image to virtual disk:
client.upload("disk.qcow2", transfer.transfer_url)
Download virtual disk to qcow2 image:
client.download(transfer.transfer_url, "disk.qcow2")
You can also upload and download using imageio REST API. For more info
on this, see imageio API documentation:
http://ovirt.github.io/ovirt-imageio/images.html
When finishing the transfer, the user should call
<
[source,python]
transfer_service.finalize()
In case of an error, the transfer's phase will be changed to
<Illegal. Otherwise it will be changed to
<
[source]
POST /ovirt-engine/api/disks
With a request body as follows:
[source,xml]
- Create a new image transfer for downloading/uploading a
diskwith id456:[source]
POST /ovirt-engine/api/imagetransfers
With a request body as follows:
[source,xml]
Will respond:
[source,xml]
Note: If the phase is 'initializing', poll the image_transfer till its phase changes to 'transferring'.
- Use the 'transfer_url' or 'proxy_url' to invoke a curl command:
- use 'transfer_url' for transferring directly from/to ovirt-imageio-daemon, or, use 'proxy_url' for transferring from/to ovirt-imageio-proxy. Note: using the proxy would mitigate scenarios where there's no direct connectivity to the daemon machine, e.g. vdsm machines are on a different network than the engine. -- Download:
[source,shell]
$ curl --cacert /etc/pki/ovirt-engine/ca.pem https://daemon_fqdn:54322/images/41c732d4-2210-4e7b-9e5c-4e2805baadbb -o
-- Upload:
[source,shell]
$ curl --cacert /etc/pki/ovirt-engine/ca.pem --upload-file -X PUT https://daemon_fqdn:54322/images/41c732d4-2210-4e7b-9e5c-4e2805baadbb
- Finalize the image transfer by invoking the action:
[source]
POST /ovirt-engine/api/imagetransfers/123/finalize
With a request body as follows:
[source,xml]
View Source
def __init__(self, connection, path): super(ImageTransferService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def cancel( self, headers=None, query=None, wait=True, **kwargs ): """ Cancel the image transfer session. This terminates the transfer operation and removes the partial image. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'cancel', None, headers, query, wait)
Cancel the image transfer session. This terminates the transfer operation and removes the partial image.
View Source
def extend( self, headers=None, query=None, wait=True, **kwargs ): """ Extend the image transfer session. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'extend', None, headers, query, wait)
Extend the image transfer session.
View Source
def finalize( self, headers=None, query=None, wait=True, **kwargs ): """ After finishing to transfer the data, finalize the transfer. This will make sure that the data being transferred is valid and fits the image entity that was targeted in the transfer. Specifically, will verify that if the image entity is a QCOW disk, the data uploaded is indeed a QCOW file, and that the image doesn't have a backing file. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'finalize', None, headers, query, wait)
After finishing to transfer the data, finalize the transfer. This will make sure that the data being transferred is valid and fits the image entity that was targeted in the transfer. Specifically, will verify that if the image entity is a QCOW disk, the data uploaded is indeed a QCOW file, and that the image doesn't have a backing file.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get the image transfer entity. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get the image transfer entity.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def pause( self, headers=None, query=None, wait=True, **kwargs ): """ Pause the image transfer session. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'pause', None, headers, query, wait)
Pause the image transfer session.
View Source
def resume( self, headers=None, query=None, wait=True, **kwargs ): """ Resume the image transfer session. The client will need to poll the transfer's phase until it is different than `resuming`. For example: [source,python] ---- transfer_service = transfers_service.image_transfer_service(transfer.id) transfer_service.resume() transfer = transfer_service.get() while transfer.phase == types.ImageTransferPhase.RESUMING: time.sleep(1) transfer = transfer_service.get() ---- """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'resume', None, headers, query, wait)
Resume the image transfer session. The client will need to poll the transfer's phase until
it is different than resuming. For example:
[source,python]
transfer_service = transfers_service.image_transfer_service(transfer.id) transfer_service.resume() transfer = transfer_service.get() while transfer.phase == types.ImageTransferPhase.RESUMING: time.sleep(1)
transfer = transfer_service.get()
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ImageTransfersService(Service): """ This service manages image transfers, for performing Image I/O API in {product-name}. Please refer to <<services/image_transfer, image transfer>> for further documentation. """ def __init__(self, connection, path): super(ImageTransfersService, self).__init__(connection, path) self._image_transfer_service = None def add( self, image_transfer, headers=None, query=None, wait=True, **kwargs ): """ Add a new image transfer. An image, disk or disk snapshot needs to be specified in order to make a new transfer. IMPORTANT: The `image` attribute is deprecated since version 4.2 of the engine. Use the `disk` or `snapshot` attributes instead. *Creating a new image transfer for downloading or uploading a `disk`:* To create an image transfer to download or upload a disk with id `123`, send the following request: [source] ---- POST /ovirt-engine/api/imagetransfers ---- With a request body like this: [source,xml] ---- <image_transfer> <disk id="123"/> <direction>upload|download</direction> </image_transfer> ---- *Creating a new image transfer for downloading or uploading a `disk_snapshot`:* To create an image transfer to download or upload a `disk_snapshot` with id `456`, send the following request: [source] ---- POST /ovirt-engine/api/imagetransfers ---- With a request body like this: [source,xml] ---- <image_transfer> <snapshot id="456"/> <direction>download|upload</direction> </image_transfer> ---- This method supports the following parameters: `image_transfer`:: The image transfer to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('image_transfer', image_transfer, types.ImageTransfer), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(image_transfer, headers, query, wait) def add_for_disk( self, image_transfer, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `image_transfer`:: The image transfer to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('image_transfer', image_transfer, types.ImageTransfer), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(image_transfer, headers, query, wait) def add_for_image( self, image_transfer, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `image_transfer`:: The image transfer to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('image_transfer', image_transfer, types.ImageTransfer), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(image_transfer, headers, query, wait) def add_for_snapshot( self, image_transfer, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `image_transfer`:: The image transfer to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('image_transfer', image_transfer, types.ImageTransfer), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(image_transfer, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the list of image transfers that are currently being performed. The order of the returned list of image transfers is not guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def image_transfer_service(self, id): """ Returns a reference to the service that manages an specific image transfer. """ Service._check_types([ ('id', id, str), ]) return ImageTransferService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.image_transfer_service(path) return self.image_transfer_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ImageTransfersService:%s' % self._path
This service manages image transfers, for performing Image I/O API in {product-name}.
Please refer to <
View Source
def __init__(self, connection, path): super(ImageTransfersService, self).__init__(connection, path) self._image_transfer_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, image_transfer, headers=None, query=None, wait=True, **kwargs ): """ Add a new image transfer. An image, disk or disk snapshot needs to be specified in order to make a new transfer. IMPORTANT: The `image` attribute is deprecated since version 4.2 of the engine. Use the `disk` or `snapshot` attributes instead. *Creating a new image transfer for downloading or uploading a `disk`:* To create an image transfer to download or upload a disk with id `123`, send the following request: [source] ---- POST /ovirt-engine/api/imagetransfers ---- With a request body like this: [source,xml] ---- <image_transfer> <disk id="123"/> <direction>upload|download</direction> </image_transfer> ---- *Creating a new image transfer for downloading or uploading a `disk_snapshot`:* To create an image transfer to download or upload a `disk_snapshot` with id `456`, send the following request: [source] ---- POST /ovirt-engine/api/imagetransfers ---- With a request body like this: [source,xml] ---- <image_transfer> <snapshot id="456"/> <direction>download|upload</direction> </image_transfer> ---- This method supports the following parameters: `image_transfer`:: The image transfer to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('image_transfer', image_transfer, types.ImageTransfer), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(image_transfer, headers, query, wait)
Add a new image transfer. An image, disk or disk snapshot needs to be specified
in order to make a new transfer.
IMPORTANT: The image attribute is deprecated since version 4.2 of the engine.
Use the disk or snapshot attributes instead.
Creating a new image transfer for downloading or uploading a disk:
To create an image transfer to download or upload a disk with id 123,
send the following request:
[source]
POST /ovirt-engine/api/imagetransfers
With a request body like this:
[source,xml]
Creating a new image transfer for downloading or uploading a disk_snapshot:
To create an image transfer to download or upload a disk_snapshot with id 456,
send the following request:
[source]
POST /ovirt-engine/api/imagetransfers
With a request body like this:
[source,xml]
This method supports the following parameters:
image_transfer:: The image transfer to add.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_for_disk( self, image_transfer, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `image_transfer`:: The image transfer to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('image_transfer', image_transfer, types.ImageTransfer), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(image_transfer, headers, query, wait)
This method supports the following parameters:
image_transfer:: The image transfer to add.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_for_image( self, image_transfer, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `image_transfer`:: The image transfer to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('image_transfer', image_transfer, types.ImageTransfer), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(image_transfer, headers, query, wait)
This method supports the following parameters:
image_transfer:: The image transfer to add.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_for_snapshot( self, image_transfer, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `image_transfer`:: The image transfer to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('image_transfer', image_transfer, types.ImageTransfer), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(image_transfer, headers, query, wait)
This method supports the following parameters:
image_transfer:: The image transfer to add.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the list of image transfers that are currently being performed. The order of the returned list of image transfers is not guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the list of image transfers that are currently being performed. The order of the returned list of image transfers is not guaranteed.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def image_transfer_service(self, id): """ Returns a reference to the service that manages an specific image transfer. """ Service._check_types([ ('id', id, str), ]) return ImageTransferService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service that manages an specific image transfer.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.image_transfer_service(path) return self.image_transfer_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ImagesService(Service): """ Manages the set of images available in an storage domain or in an OpenStack image provider. """ def __init__(self, connection, path): super(ImagesService, self).__init__(connection, path) self._image_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of images available in the storage domain or provider. The order of the returned list of images isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of images to return. If not specified all the images are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def image_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ImageService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.image_service(path) return self.image_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'ImagesService:%s' % self._path
Manages the set of images available in an storage domain or in an OpenStack image provider.
View Source
def __init__(self, connection, path): super(ImagesService, self).__init__(connection, path) self._image_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of images available in the storage domain or provider. The order of the returned list of images isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of images to return. If not specified all the images are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of images available in the storage domain or provider. The order of the returned list of images isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of images to return. If not specified all the images are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def image_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return ImageService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.image_service(path) return self.image_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class InstanceTypeService(Service): """ """ def __init__(self, connection, path): super(InstanceTypeService, self).__init__(connection, path) self._graphics_consoles_service = None self._nics_service = None self._watchdogs_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get a specific instance type and it's attributes. [source] ---- GET /ovirt-engine/api/instancetypes/123 ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a specific instance type from the system. If a virtual machine was created using an instance type X after removal of the instance type the virtual machine's instance type will be set to `custom`. [source] ---- DELETE /ovirt-engine/api/instancetypes/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, instance_type, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update a specific instance type and it's attributes. All the attributes are editable after creation. If a virtual machine was created using an instance type X and some configuration in instance type X was updated, the virtual machine's configuration will be updated automatically by the engine. [source] ---- PUT /ovirt-engine/api/instancetypes/123 ---- For example, to update the memory of instance type `123` to 1 GiB and set the cpu topology to 2 sockets and 1 core, send a request like this: [source, xml] ---- <instance_type> <memory>1073741824</memory> <cpu> <topology> <cores>1</cores> <sockets>2</sockets> <threads>1</threads> </topology> </cpu> </instance_type> ---- """ # Check the types of the parameters: Service._check_types([ ('instance_type', instance_type, types.InstanceType), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(instance_type, headers, query, wait) def graphics_consoles_service(self): """ Reference to the service that manages the graphic consoles that are attached to this instance type. """ return InstanceTypeGraphicsConsolesService(self._connection, '%s/graphicsconsoles' % self._path) def nics_service(self): """ Reference to the service that manages the NICs that are attached to this instance type. """ return InstanceTypeNicsService(self._connection, '%s/nics' % self._path) def watchdogs_service(self): """ Reference to the service that manages the watchdogs that are attached to this instance type. """ return InstanceTypeWatchdogsService(self._connection, '%s/watchdogs' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'graphicsconsoles': return self.graphics_consoles_service() if path.startswith('graphicsconsoles/'): return self.graphics_consoles_service().service(path[17:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) if path == 'watchdogs': return self.watchdogs_service() if path.startswith('watchdogs/'): return self.watchdogs_service().service(path[10:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'InstanceTypeService:%s' % self._path
View Source
def __init__(self, connection, path): super(InstanceTypeService, self).__init__(connection, path) self._graphics_consoles_service = None self._nics_service = None self._watchdogs_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get a specific instance type and it's attributes. [source] ---- GET /ovirt-engine/api/instancetypes/123 ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get a specific instance type and it's attributes.
[source]
GET /ovirt-engine/api/instancetypes/123
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a specific instance type from the system. If a virtual machine was created using an instance type X after removal of the instance type the virtual machine's instance type will be set to `custom`. [source] ---- DELETE /ovirt-engine/api/instancetypes/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes a specific instance type from the system.
If a virtual machine was created using an instance type X after removal of the instance type
the virtual machine's instance type will be set to custom.
[source]
DELETE /ovirt-engine/api/instancetypes/123
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, instance_type, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update a specific instance type and it's attributes. All the attributes are editable after creation. If a virtual machine was created using an instance type X and some configuration in instance type X was updated, the virtual machine's configuration will be updated automatically by the engine. [source] ---- PUT /ovirt-engine/api/instancetypes/123 ---- For example, to update the memory of instance type `123` to 1 GiB and set the cpu topology to 2 sockets and 1 core, send a request like this: [source, xml] ---- <instance_type> <memory>1073741824</memory> <cpu> <topology> <cores>1</cores> <sockets>2</sockets> <threads>1</threads> </topology> </cpu> </instance_type> ---- """ # Check the types of the parameters: Service._check_types([ ('instance_type', instance_type, types.InstanceType), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(instance_type, headers, query, wait)
Update a specific instance type and it's attributes. All the attributes are editable after creation. If a virtual machine was created using an instance type X and some configuration in instance type X was updated, the virtual machine's configuration will be updated automatically by the engine.
[source]
PUT /ovirt-engine/api/instancetypes/123
For example, to update the memory of instance type 123 to 1 GiB and set the cpu topology
to 2 sockets and 1 core, send a request like this:
[source, xml]
View Source
def graphics_consoles_service(self): """ Reference to the service that manages the graphic consoles that are attached to this instance type. """ return InstanceTypeGraphicsConsolesService(self._connection, '%s/graphicsconsoles' % self._path)
Reference to the service that manages the graphic consoles that are attached to this instance type.
View Source
def nics_service(self): """ Reference to the service that manages the NICs that are attached to this instance type. """ return InstanceTypeNicsService(self._connection, '%s/nics' % self._path)
Reference to the service that manages the NICs that are attached to this instance type.
View Source
def watchdogs_service(self): """ Reference to the service that manages the watchdogs that are attached to this instance type. """ return InstanceTypeWatchdogsService(self._connection, '%s/watchdogs' % self._path)
Reference to the service that manages the watchdogs that are attached to this instance type.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'graphicsconsoles': return self.graphics_consoles_service() if path.startswith('graphicsconsoles/'): return self.graphics_consoles_service().service(path[17:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) if path == 'watchdogs': return self.watchdogs_service() if path.startswith('watchdogs/'): return self.watchdogs_service().service(path[10:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class InstanceTypeGraphicsConsoleService(Service): """ """ def __init__(self, connection, path): super(InstanceTypeGraphicsConsoleService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets graphics console configuration of the instance type. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the graphics console from the instance type. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'InstanceTypeGraphicsConsoleService:%s' % self._path
View Source
def __init__(self, connection, path): super(InstanceTypeGraphicsConsoleService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets graphics console configuration of the instance type. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets graphics console configuration of the instance type.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the graphics console from the instance type. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove the graphics console from the instance type.
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class InstanceTypeGraphicsConsolesService(Service): """ """ def __init__(self, connection, path): super(InstanceTypeGraphicsConsolesService, self).__init__(connection, path) self._console_service = None def add( self, console, headers=None, query=None, wait=True, **kwargs ): """ Add new graphics console to the instance type. """ # Check the types of the parameters: Service._check_types([ ('console', console, types.GraphicsConsole), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(console, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured graphics consoles of the instance type. The order of the returned list of graphics consoles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of consoles to return. If not specified all the consoles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def console_service(self, id): """ Returns a reference to the service that manages a specific instance type graphics console. """ Service._check_types([ ('id', id, str), ]) return InstanceTypeGraphicsConsoleService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.console_service(path) return self.console_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'InstanceTypeGraphicsConsolesService:%s' % self._path
View Source
def __init__(self, connection, path): super(InstanceTypeGraphicsConsolesService, self).__init__(connection, path) self._console_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, console, headers=None, query=None, wait=True, **kwargs ): """ Add new graphics console to the instance type. """ # Check the types of the parameters: Service._check_types([ ('console', console, types.GraphicsConsole), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(console, headers, query, wait)
Add new graphics console to the instance type.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured graphics consoles of the instance type. The order of the returned list of graphics consoles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of consoles to return. If not specified all the consoles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists all the configured graphics consoles of the instance type. The order of the returned list of graphics consoles isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of consoles to return. If not specified all the consoles are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def console_service(self, id): """ Returns a reference to the service that manages a specific instance type graphics console. """ Service._check_types([ ('id', id, str), ]) return InstanceTypeGraphicsConsoleService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service that manages a specific instance type graphics console.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.console_service(path) return self.console_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class InstanceTypeNicService(Service): """ """ def __init__(self, connection, path): super(InstanceTypeNicService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets network interface configuration of the instance type. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the network interface from the instance type. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, nic, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the network interface configuration of the instance type. """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(nic, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'InstanceTypeNicService:%s' % self._path
View Source
def __init__(self, connection, path): super(InstanceTypeNicService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets network interface configuration of the instance type. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets network interface configuration of the instance type.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the network interface from the instance type. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove the network interface from the instance type.
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, nic, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the network interface configuration of the instance type. """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(nic, headers, query, wait)
Updates the network interface configuration of the instance type.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class InstanceTypeNicsService(Service): """ """ def __init__(self, connection, path): super(InstanceTypeNicsService, self).__init__(connection, path) self._nic_service = None def add( self, nic, headers=None, query=None, wait=True, **kwargs ): """ Add new network interface to the instance type. """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(nic, headers, query, wait) def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured network interface of the instance type. The order of the returned list of network interfaces isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `search`:: A query string used to restrict the returned templates. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def nic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return InstanceTypeNicService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'InstanceTypeNicsService:%s' % self._path
View Source
def __init__(self, connection, path): super(InstanceTypeNicsService, self).__init__(connection, path) self._nic_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, nic, headers=None, query=None, wait=True, **kwargs ): """ Add new network interface to the instance type. """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(nic, headers, query, wait)
Add new network interface to the instance type.
#
def
list(
self,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured network interface of the instance type. The order of the returned list of network interfaces isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `search`:: A query string used to restrict the returned templates. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists all the configured network interface of the instance type. The order of the returned list of network interfaces isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of NICs to return. If not specified all the NICs are returned.
search:: A query string used to restrict the returned templates.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def nic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return InstanceTypeNicService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class InstanceTypeWatchdogService(Service): """ """ def __init__(self, connection, path): super(InstanceTypeWatchdogService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets watchdog configuration of the instance type. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove a watchdog from the instance type. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, watchdog, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the watchdog configuration of the instance type. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(watchdog, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'InstanceTypeWatchdogService:%s' % self._path
View Source
def __init__(self, connection, path): super(InstanceTypeWatchdogService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets watchdog configuration of the instance type. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets watchdog configuration of the instance type.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove a watchdog from the instance type. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove a watchdog from the instance type.
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, watchdog, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the watchdog configuration of the instance type. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(watchdog, headers, query, wait)
Updates the watchdog configuration of the instance type.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class InstanceTypeWatchdogsService(Service): """ """ def __init__(self, connection, path): super(InstanceTypeWatchdogsService, self).__init__(connection, path) self._watchdog_service = None def add( self, watchdog, headers=None, query=None, wait=True, **kwargs ): """ Add new watchdog to the instance type. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(watchdog, headers, query, wait) def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured watchdogs of the instance type. The order of the returned list of watchdogs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of watchdogs to return. If not specified all the watchdogs are returned. `search`:: A query string used to restrict the returned templates. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def watchdog_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return InstanceTypeWatchdogService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.watchdog_service(path) return self.watchdog_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'InstanceTypeWatchdogsService:%s' % self._path
View Source
def __init__(self, connection, path): super(InstanceTypeWatchdogsService, self).__init__(connection, path) self._watchdog_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, watchdog, headers=None, query=None, wait=True, **kwargs ): """ Add new watchdog to the instance type. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(watchdog, headers, query, wait)
Add new watchdog to the instance type.
#
def
list(
self,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured watchdogs of the instance type. The order of the returned list of watchdogs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of watchdogs to return. If not specified all the watchdogs are returned. `search`:: A query string used to restrict the returned templates. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists all the configured watchdogs of the instance type. The order of the returned list of watchdogs isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of watchdogs to return. If not specified all the watchdogs are
returned.
search:: A query string used to restrict the returned templates.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def watchdog_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return InstanceTypeWatchdogService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.watchdog_service(path) return self.watchdog_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class InstanceTypesService(Service): """ """ def __init__(self, connection, path): super(InstanceTypesService, self).__init__(connection, path) self._instance_type_service = None def add( self, instance_type, headers=None, query=None, wait=True, **kwargs ): """ Creates a new instance type. This requires only a name attribute and can include all hardware configurations of the virtual machine. [source] ---- POST /ovirt-engine/api/instancetypes ---- With a request body like this: [source,xml] ---- <instance_type> <name>myinstancetype</name> </template> ---- Creating an instance type with all hardware configurations with a request body like this: [source,xml] ---- <instance_type> <name>myinstancetype</name> <console> <enabled>true</enabled> </console> <cpu> <topology> <cores>2</cores> <sockets>2</sockets> <threads>1</threads> </topology> </cpu> <custom_cpu_model>AMD Opteron_G2</custom_cpu_model> <custom_emulated_machine>q35</custom_emulated_machine> <display> <monitors>1</monitors> <single_qxl_pci>true</single_qxl_pci> <smartcard_enabled>true</smartcard_enabled> <type>spice</type> </display> <high_availability> <enabled>true</enabled> <priority>1</priority> </high_availability> <io> <threads>2</threads> </io> <memory>4294967296</memory> <memory_policy> <ballooning>true</ballooning> <guaranteed>268435456</guaranteed> </memory_policy> <migration> <auto_converge>inherit</auto_converge> <compressed>inherit</compressed> <policy id="00000000-0000-0000-0000-000000000000"/> </migration> <migration_downtime>2</migration_downtime> <os> <boot> <devices> <device>hd</device> </devices> </boot> </os> <rng_device> <rate> <bytes>200</bytes> <period>2</period> </rate> <source>urandom</source> </rng_device> <soundcard_enabled>true</soundcard_enabled> <usb> <enabled>true</enabled> <type>native</type> </usb> <virtio_scsi> <enabled>true</enabled> </virtio_scsi> </instance_type> ---- """ # Check the types of the parameters: Service._check_types([ ('instance_type', instance_type, types.InstanceType), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(instance_type, headers, query, wait) def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all existing instance types in the system. The order of the returned list of instance types isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of instance types to return. If not specified all the instance types are returned. `search`:: A query string used to restrict the returned templates. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def instance_type_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return InstanceTypeService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.instance_type_service(path) return self.instance_type_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'InstanceTypesService:%s' % self._path
View Source
def __init__(self, connection, path): super(InstanceTypesService, self).__init__(connection, path) self._instance_type_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, instance_type, headers=None, query=None, wait=True, **kwargs ): """ Creates a new instance type. This requires only a name attribute and can include all hardware configurations of the virtual machine. [source] ---- POST /ovirt-engine/api/instancetypes ---- With a request body like this: [source,xml] ---- <instance_type> <name>myinstancetype</name> </template> ---- Creating an instance type with all hardware configurations with a request body like this: [source,xml] ---- <instance_type> <name>myinstancetype</name> <console> <enabled>true</enabled> </console> <cpu> <topology> <cores>2</cores> <sockets>2</sockets> <threads>1</threads> </topology> </cpu> <custom_cpu_model>AMD Opteron_G2</custom_cpu_model> <custom_emulated_machine>q35</custom_emulated_machine> <display> <monitors>1</monitors> <single_qxl_pci>true</single_qxl_pci> <smartcard_enabled>true</smartcard_enabled> <type>spice</type> </display> <high_availability> <enabled>true</enabled> <priority>1</priority> </high_availability> <io> <threads>2</threads> </io> <memory>4294967296</memory> <memory_policy> <ballooning>true</ballooning> <guaranteed>268435456</guaranteed> </memory_policy> <migration> <auto_converge>inherit</auto_converge> <compressed>inherit</compressed> <policy id="00000000-0000-0000-0000-000000000000"/> </migration> <migration_downtime>2</migration_downtime> <os> <boot> <devices> <device>hd</device> </devices> </boot> </os> <rng_device> <rate> <bytes>200</bytes> <period>2</period> </rate> <source>urandom</source> </rng_device> <soundcard_enabled>true</soundcard_enabled> <usb> <enabled>true</enabled> <type>native</type> </usb> <virtio_scsi> <enabled>true</enabled> </virtio_scsi> </instance_type> ---- """ # Check the types of the parameters: Service._check_types([ ('instance_type', instance_type, types.InstanceType), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(instance_type, headers, query, wait)
Creates a new instance type. This requires only a name attribute and can include all hardware configurations of the virtual machine.
[source]
POST /ovirt-engine/api/instancetypes
With a request body like this:
[source,xml]
Creating an instance type with all hardware configurations with a request body like this:
[source,xml]
#
def
list(
self,
case_sensitive=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all existing instance types in the system. The order of the returned list of instance types isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of instance types to return. If not specified all the instance types are returned. `search`:: A query string used to restrict the returned templates. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists all existing instance types in the system. The order of the returned list of instance types isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of instance types to return. If not specified all the instance
types are returned.
search:: A query string used to restrict the returned templates.
case_sensitive:: Indicates if the search performed using the search parameter should be performed
taking case into account. The default value is true, which means that case is taken
into account. If you want to search ignoring case set it to false.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def instance_type_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return InstanceTypeService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.instance_type_service(path) return self.instance_type_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class IscsiBondService(Service): """ """ def __init__(self, connection, path): super(IscsiBondService, self).__init__(connection, path) self._networks_service = None self._storage_server_connections_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes of an existing iSCSI bond. For example, to remove the iSCSI bond `456` send a request like this: [source] ---- DELETE /ovirt-engine/api/datacenters/123/iscsibonds/456 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, bond, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates an iSCSI bond. Updating of an iSCSI bond can be done on the `name` and the `description` attributes only. For example, to update the iSCSI bond `456` of data center `123`, send a request like this: [source] ---- PUT /ovirt-engine/api/datacenters/123/iscsibonds/1234 ---- The request body should look like this: [source,xml] ---- <iscsi_bond> <name>mybond</name> <description>My iSCSI bond</description> </iscsi_bond> ---- This method supports the following parameters: `bond`:: The iSCSI bond to update. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bond', bond, types.IscsiBond), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(bond, headers, query, wait) def networks_service(self): """ """ return NetworksService(self._connection, '%s/networks' % self._path) def storage_server_connections_service(self): """ """ return StorageServerConnectionsService(self._connection, '%s/storageserverconnections' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) if path == 'storageserverconnections': return self.storage_server_connections_service() if path.startswith('storageserverconnections/'): return self.storage_server_connections_service().service(path[25:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'IscsiBondService:%s' % self._path
View Source
def __init__(self, connection, path): super(IscsiBondService, self).__init__(connection, path) self._networks_service = None self._storage_server_connections_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes of an existing iSCSI bond. For example, to remove the iSCSI bond `456` send a request like this: [source] ---- DELETE /ovirt-engine/api/datacenters/123/iscsibonds/456 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes of an existing iSCSI bond.
For example, to remove the iSCSI bond 456 send a request like this:
[source]
DELETE /ovirt-engine/api/datacenters/123/iscsibonds/456
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, bond, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates an iSCSI bond. Updating of an iSCSI bond can be done on the `name` and the `description` attributes only. For example, to update the iSCSI bond `456` of data center `123`, send a request like this: [source] ---- PUT /ovirt-engine/api/datacenters/123/iscsibonds/1234 ---- The request body should look like this: [source,xml] ---- <iscsi_bond> <name>mybond</name> <description>My iSCSI bond</description> </iscsi_bond> ---- This method supports the following parameters: `bond`:: The iSCSI bond to update. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('bond', bond, types.IscsiBond), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(bond, headers, query, wait)
Updates an iSCSI bond.
Updating of an iSCSI bond can be done on the name and the description attributes only. For example, to
update the iSCSI bond 456 of data center 123, send a request like this:
[source]
PUT /ovirt-engine/api/datacenters/123/iscsibonds/1234
The request body should look like this:
[source,xml]
This method supports the following parameters:
bond:: The iSCSI bond to update.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def networks_service(self): """ """ return NetworksService(self._connection, '%s/networks' % self._path)
View Source
def storage_server_connections_service(self): """ """ return StorageServerConnectionsService(self._connection, '%s/storageserverconnections' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) if path == 'storageserverconnections': return self.storage_server_connections_service() if path.startswith('storageserverconnections/'): return self.storage_server_connections_service().service(path[25:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class IscsiBondsService(Service): """ """ def __init__(self, connection, path): super(IscsiBondsService, self).__init__(connection, path) self._iscsi_bond_service = None def add( self, bond, headers=None, query=None, wait=True, **kwargs ): """ Create a new iSCSI bond on a data center. For example, to create a new iSCSI bond on data center `123` using storage connections `456` and `789`, send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/iscsibonds ---- The request body should look like this: [source,xml] ---- <iscsi_bond> <name>mybond</name> <storage_connections> <storage_connection id="456"/> <storage_connection id="789"/> </storage_connections> <networks> <network id="abc"/> </networks> </iscsi_bond> ---- """ # Check the types of the parameters: Service._check_types([ ('bond', bond, types.IscsiBond), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(bond, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of iSCSI bonds configured in the data center. The order of the returned list of iSCSI bonds isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of bonds to return. If not specified all the bonds are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def iscsi_bond_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return IscsiBondService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.iscsi_bond_service(path) return self.iscsi_bond_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'IscsiBondsService:%s' % self._path
View Source
def __init__(self, connection, path): super(IscsiBondsService, self).__init__(connection, path) self._iscsi_bond_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, bond, headers=None, query=None, wait=True, **kwargs ): """ Create a new iSCSI bond on a data center. For example, to create a new iSCSI bond on data center `123` using storage connections `456` and `789`, send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/iscsibonds ---- The request body should look like this: [source,xml] ---- <iscsi_bond> <name>mybond</name> <storage_connections> <storage_connection id="456"/> <storage_connection id="789"/> </storage_connections> <networks> <network id="abc"/> </networks> </iscsi_bond> ---- """ # Check the types of the parameters: Service._check_types([ ('bond', bond, types.IscsiBond), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(bond, headers, query, wait)
Create a new iSCSI bond on a data center.
For example, to create a new iSCSI bond on data center 123 using storage connections 456 and 789, send a
request like this:
[source]
POST /ovirt-engine/api/datacenters/123/iscsibonds
The request body should look like this:
[source,xml]
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of iSCSI bonds configured in the data center. The order of the returned list of iSCSI bonds isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of bonds to return. If not specified all the bonds are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of iSCSI bonds configured in the data center. The order of the returned list of iSCSI bonds isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of bonds to return. If not specified all the bonds are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def iscsi_bond_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return IscsiBondService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.iscsi_bond_service(path) return self.iscsi_bond_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class JobService(Service): """ A service to manage a job. """ def __init__(self, connection, path): super(JobService, self).__init__(connection, path) self._steps_service = None def clear( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Set an external job execution to be cleared by the system. For example, to set a job with identifier `123` send the following request: [source] ---- POST /ovirt-engine/api/jobs/clear ---- With the following request body: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'clear', None, headers, query, wait) def end( self, async_=None, force=None, succeeded=None, headers=None, query=None, wait=True, **kwargs ): """ Marks an external job execution as ended. For example, to terminate a job with identifier `123` send the following request: [source] ---- POST /ovirt-engine/api/jobs/end ---- With the following request body: [source,xml] ---- <action> <force>true</force> <status>finished</status> </action> ---- This method supports the following parameters: `force`:: Indicates if the job should be forcibly terminated. `succeeded`:: Indicates if the job should be marked as successfully finished or as failed. This parameter is optional, and the default value is `true`. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('succeeded', succeeded, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, succeeded=succeeded, ) # Send the request and wait for the response: return self._internal_action(action, 'end', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a job. [source] ---- GET /ovirt-engine/api/jobs/123 ---- You will receive response in XML like this one: [source,xml] ---- <job href="/ovirt-engine/api/jobs/123" id="123"> <actions> <link href="/ovirt-engine/api/jobs/123/clear" rel="clear"/> <link href="/ovirt-engine/api/jobs/123/end" rel="end"/> </actions> <description>Adding Disk</description> <link href="/ovirt-engine/api/jobs/123/steps" rel="steps"/> <auto_cleared>true</auto_cleared> <end_time>2016-12-12T23:07:29.758+02:00</end_time> <external>false</external> <last_updated>2016-12-12T23:07:29.758+02:00</last_updated> <start_time>2016-12-12T23:07:26.593+02:00</start_time> <status>failed</status> <owner href="/ovirt-engine/api/users/456" id="456"/> </job> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def steps_service(self): """ List all the steps of the job. The order of the returned list of steps isn't guaranteed. """ return StepsService(self._connection, '%s/steps' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'steps': return self.steps_service() if path.startswith('steps/'): return self.steps_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'JobService:%s' % self._path
A service to manage a job.
View Source
def __init__(self, connection, path): super(JobService, self).__init__(connection, path) self._steps_service = None
Creates a new service that will use the given connection and path.
View Source
def clear( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Set an external job execution to be cleared by the system. For example, to set a job with identifier `123` send the following request: [source] ---- POST /ovirt-engine/api/jobs/clear ---- With the following request body: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'clear', None, headers, query, wait)
Set an external job execution to be cleared by the system.
For example, to set a job with identifier 123 send the following request:
[source]
POST /ovirt-engine/api/jobs/clear
With the following request body:
[source,xml]
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
end(
self,
async_=None,
force=None,
succeeded=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def end( self, async_=None, force=None, succeeded=None, headers=None, query=None, wait=True, **kwargs ): """ Marks an external job execution as ended. For example, to terminate a job with identifier `123` send the following request: [source] ---- POST /ovirt-engine/api/jobs/end ---- With the following request body: [source,xml] ---- <action> <force>true</force> <status>finished</status> </action> ---- This method supports the following parameters: `force`:: Indicates if the job should be forcibly terminated. `succeeded`:: Indicates if the job should be marked as successfully finished or as failed. This parameter is optional, and the default value is `true`. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('succeeded', succeeded, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, succeeded=succeeded, ) # Send the request and wait for the response: return self._internal_action(action, 'end', None, headers, query, wait)
Marks an external job execution as ended.
For example, to terminate a job with identifier 123 send the following request:
[source]
POST /ovirt-engine/api/jobs/end
With the following request body:
[source,xml]
This method supports the following parameters:
force:: Indicates if the job should be forcibly terminated.
succeeded:: Indicates if the job should be marked as successfully finished or as failed.
This parameter is optional, and the default value is true.
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a job. [source] ---- GET /ovirt-engine/api/jobs/123 ---- You will receive response in XML like this one: [source,xml] ---- <job href="/ovirt-engine/api/jobs/123" id="123"> <actions> <link href="/ovirt-engine/api/jobs/123/clear" rel="clear"/> <link href="/ovirt-engine/api/jobs/123/end" rel="end"/> </actions> <description>Adding Disk</description> <link href="/ovirt-engine/api/jobs/123/steps" rel="steps"/> <auto_cleared>true</auto_cleared> <end_time>2016-12-12T23:07:29.758+02:00</end_time> <external>false</external> <last_updated>2016-12-12T23:07:29.758+02:00</last_updated> <start_time>2016-12-12T23:07:26.593+02:00</start_time> <status>failed</status> <owner href="/ovirt-engine/api/users/456" id="456"/> </job> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves a job.
[source]
GET /ovirt-engine/api/jobs/123
You will receive response in XML like this one:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def steps_service(self): """ List all the steps of the job. The order of the returned list of steps isn't guaranteed. """ return StepsService(self._connection, '%s/steps' % self._path)
List all the steps of the job. The order of the returned list of steps isn't guaranteed.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'steps': return self.steps_service() if path.startswith('steps/'): return self.steps_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class JobsService(Service): """ A service to manage jobs. """ def __init__(self, connection, path): super(JobsService, self).__init__(connection, path) self._job_service = None def add( self, job, headers=None, query=None, wait=True, **kwargs ): """ Add an external job. For example, to add a job with the following request: [source] ---- POST /ovirt-engine/api/jobs ---- With the following request body: [source,xml] ---- <job> <description>Doing some work</description> <auto_cleared>true</auto_cleared> </job> ---- The response should look like: [source,xml] ---- <job href="/ovirt-engine/api/jobs/123" id="123"> <actions> <link href="/ovirt-engine/api/jobs/123/clear" rel="clear"/> <link href="/ovirt-engine/api/jobs/123/end" rel="end"/> </actions> <description>Doing some work</description> <link href="/ovirt-engine/api/jobs/123/steps" rel="steps"/> <auto_cleared>true</auto_cleared> <external>true</external> <last_updated>2016-12-13T02:15:42.130+02:00</last_updated> <start_time>2016-12-13T02:15:42.130+02:00</start_time> <status>started</status> <owner href="/ovirt-engine/api/users/456" id="456"/> </job> ---- This method supports the following parameters: `job`:: Job that will be added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('job', job, types.Job), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(job, headers, query, wait) def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representation of the jobs. [source] ---- GET /ovirt-engine/api/jobs ---- You will receive response in XML like this one: [source,xml] ---- <jobs> <job href="/ovirt-engine/api/jobs/123" id="123"> <actions> <link href="/ovirt-engine/api/jobs/123/clear" rel="clear"/> <link href="/ovirt-engine/api/jobs/123/end" rel="end"/> </actions> <description>Adding Disk</description> <link href="/ovirt-engine/api/jobs/123/steps" rel="steps"/> <auto_cleared>true</auto_cleared> <end_time>2016-12-12T23:07:29.758+02:00</end_time> <external>false</external> <last_updated>2016-12-12T23:07:29.758+02:00</last_updated> <start_time>2016-12-12T23:07:26.593+02:00</start_time> <status>failed</status> <owner href="/ovirt-engine/api/users/456" id="456"/> </job> ... </jobs> ---- The order of the returned list of jobs isn't guaranteed. This method supports the following parameters: `search`:: A query string used to restrict the returned jobs. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `max`:: Sets the maximum number of jobs to return. If not specified all the jobs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def job_service(self, id): """ Reference to the job service. """ Service._check_types([ ('id', id, str), ]) return JobService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.job_service(path) return self.job_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'JobsService:%s' % self._path
A service to manage jobs.
View Source
def __init__(self, connection, path): super(JobsService, self).__init__(connection, path) self._job_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, job, headers=None, query=None, wait=True, **kwargs ): """ Add an external job. For example, to add a job with the following request: [source] ---- POST /ovirt-engine/api/jobs ---- With the following request body: [source,xml] ---- <job> <description>Doing some work</description> <auto_cleared>true</auto_cleared> </job> ---- The response should look like: [source,xml] ---- <job href="/ovirt-engine/api/jobs/123" id="123"> <actions> <link href="/ovirt-engine/api/jobs/123/clear" rel="clear"/> <link href="/ovirt-engine/api/jobs/123/end" rel="end"/> </actions> <description>Doing some work</description> <link href="/ovirt-engine/api/jobs/123/steps" rel="steps"/> <auto_cleared>true</auto_cleared> <external>true</external> <last_updated>2016-12-13T02:15:42.130+02:00</last_updated> <start_time>2016-12-13T02:15:42.130+02:00</start_time> <status>started</status> <owner href="/ovirt-engine/api/users/456" id="456"/> </job> ---- This method supports the following parameters: `job`:: Job that will be added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('job', job, types.Job), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(job, headers, query, wait)
Add an external job. For example, to add a job with the following request:
[source]
POST /ovirt-engine/api/jobs
With the following request body:
[source,xml]
The response should look like:
[source,xml]
This method supports the following parameters:
job:: Job that will be added.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
list(
self,
case_sensitive=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representation of the jobs. [source] ---- GET /ovirt-engine/api/jobs ---- You will receive response in XML like this one: [source,xml] ---- <jobs> <job href="/ovirt-engine/api/jobs/123" id="123"> <actions> <link href="/ovirt-engine/api/jobs/123/clear" rel="clear"/> <link href="/ovirt-engine/api/jobs/123/end" rel="end"/> </actions> <description>Adding Disk</description> <link href="/ovirt-engine/api/jobs/123/steps" rel="steps"/> <auto_cleared>true</auto_cleared> <end_time>2016-12-12T23:07:29.758+02:00</end_time> <external>false</external> <last_updated>2016-12-12T23:07:29.758+02:00</last_updated> <start_time>2016-12-12T23:07:26.593+02:00</start_time> <status>failed</status> <owner href="/ovirt-engine/api/users/456" id="456"/> </job> ... </jobs> ---- The order of the returned list of jobs isn't guaranteed. This method supports the following parameters: `search`:: A query string used to restrict the returned jobs. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `max`:: Sets the maximum number of jobs to return. If not specified all the jobs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the representation of the jobs.
[source]
GET /ovirt-engine/api/jobs
You will receive response in XML like this one:
[source,xml]
The order of the returned list of jobs isn't guaranteed.
This method supports the following parameters:
search:: A query string used to restrict the returned jobs.
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
max:: Sets the maximum number of jobs to return. If not specified all the jobs are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def job_service(self, id): """ Reference to the job service. """ Service._check_types([ ('id', id, str), ]) return JobService(self._connection, '%s/%s' % (self._path, id))
Reference to the job service.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.job_service(path) return self.job_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class KatelloErrataService(Service): """ A service to manage Katello errata. The information is retrieved from Katello. """ def __init__(self, connection, path): super(KatelloErrataService, self).__init__(connection, path) self._katello_erratum_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representation of the Katello errata. [source] ---- GET /ovirt-engine/api/katelloerrata ---- You will receive response in XML like this one: [source,xml] ---- <katello_errata> <katello_erratum href="/ovirt-engine/api/katelloerrata/123" id="123"> <name>RHBA-2013:XYZ</name> <description>The description of the erratum</description> <title>some bug fix update</title> <type>bugfix</type> <issued>2013-11-20T02:00:00.000+02:00</issued> <solution>Few guidelines regarding the solution</solution> <summary>Updated packages that fix one bug are now available for XYZ</summary> <packages> <package> <name>libipa_hbac-1.9.2-82.11.el6_4.i686</name> </package> ... </packages> </katello_erratum> ... </katello_errata> ---- The order of the returned list of erratum isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of errata to return. If not specified all the errata are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def katello_erratum_service(self, id): """ Reference to the Katello erratum service. Use this service to view the erratum by its id. """ Service._check_types([ ('id', id, str), ]) return KatelloErratumService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.katello_erratum_service(path) return self.katello_erratum_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'KatelloErrataService:%s' % self._path
A service to manage Katello errata. The information is retrieved from Katello.
View Source
def __init__(self, connection, path): super(KatelloErrataService, self).__init__(connection, path) self._katello_erratum_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representation of the Katello errata. [source] ---- GET /ovirt-engine/api/katelloerrata ---- You will receive response in XML like this one: [source,xml] ---- <katello_errata> <katello_erratum href="/ovirt-engine/api/katelloerrata/123" id="123"> <name>RHBA-2013:XYZ</name> <description>The description of the erratum</description> <title>some bug fix update</title> <type>bugfix</type> <issued>2013-11-20T02:00:00.000+02:00</issued> <solution>Few guidelines regarding the solution</solution> <summary>Updated packages that fix one bug are now available for XYZ</summary> <packages> <package> <name>libipa_hbac-1.9.2-82.11.el6_4.i686</name> </package> ... </packages> </katello_erratum> ... </katello_errata> ---- The order of the returned list of erratum isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of errata to return. If not specified all the errata are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the representation of the Katello errata.
[source]
GET /ovirt-engine/api/katelloerrata
You will receive response in XML like this one:
[source,xml]
The order of the returned list of erratum isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of errata to return. If not specified all the errata are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def katello_erratum_service(self, id): """ Reference to the Katello erratum service. Use this service to view the erratum by its id. """ Service._check_types([ ('id', id, str), ]) return KatelloErratumService(self._connection, '%s/%s' % (self._path, id))
Reference to the Katello erratum service. Use this service to view the erratum by its id.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.katello_erratum_service(path) return self.katello_erratum_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class KatelloErratumService(Service): """ A service to manage a Katello erratum. """ def __init__(self, connection, path): super(KatelloErratumService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a Katello erratum. [source] ---- GET /ovirt-engine/api/katelloerrata/123 ---- You will receive response in XML like this one: [source,xml] ---- <katello_erratum href="/ovirt-engine/api/katelloerrata/123" id="123"> <name>RHBA-2013:XYZ</name> <description>The description of the erratum</description> <title>some bug fix update</title> <type>bugfix</type> <issued>2013-11-20T02:00:00.000+02:00</issued> <solution>Few guidelines regarding the solution</solution> <summary>Updated packages that fix one bug are now available for XYZ</summary> <packages> <package> <name>libipa_hbac-1.9.2-82.11.el6_4.i686</name> </package> ... </packages> </katello_erratum> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'KatelloErratumService:%s' % self._path
A service to manage a Katello erratum.
View Source
def __init__(self, connection, path): super(KatelloErratumService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a Katello erratum. [source] ---- GET /ovirt-engine/api/katelloerrata/123 ---- You will receive response in XML like this one: [source,xml] ---- <katello_erratum href="/ovirt-engine/api/katelloerrata/123" id="123"> <name>RHBA-2013:XYZ</name> <description>The description of the erratum</description> <title>some bug fix update</title> <type>bugfix</type> <issued>2013-11-20T02:00:00.000+02:00</issued> <solution>Few guidelines regarding the solution</solution> <summary>Updated packages that fix one bug are now available for XYZ</summary> <packages> <package> <name>libipa_hbac-1.9.2-82.11.el6_4.i686</name> </package> ... </packages> </katello_erratum> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves a Katello erratum.
[source]
GET /ovirt-engine/api/katelloerrata/123
You will receive response in XML like this one:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class LinkLayerDiscoveryProtocolService(Service): """ A service to fetch information elements received by Link Layer Discovery Protocol (LLDP). """ def __init__(self, connection, path): super(LinkLayerDiscoveryProtocolService, self).__init__(connection, path) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Fetches information elements received by LLDP. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'LinkLayerDiscoveryProtocolService:%s' % self._path
A service to fetch information elements received by Link Layer Discovery Protocol (LLDP).
View Source
def __init__(self, connection, path): super(LinkLayerDiscoveryProtocolService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Fetches information elements received by LLDP. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Fetches information elements received by LLDP.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class MacPoolService(Service): """ """ def __init__(self, connection, path): super(MacPoolService, self).__init__(connection, path) self._permissions_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a MAC address pool. For example, to remove the MAC address pool having id `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/macpools/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, pool, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a MAC address pool. The `name`, `description`, `allow_duplicates`, and `ranges` attributes can be updated. For example, to update the MAC address pool of id `123` send a request like this: [source] ---- PUT /ovirt-engine/api/macpools/123 ---- With a request body like this: [source,xml] ---- <mac_pool> <name>UpdatedMACPool</name> <description>An updated MAC address pool</description> <allow_duplicates>false</allow_duplicates> <ranges> <range> <from>00:1A:4A:16:01:51</from> <to>00:1A:4A:16:01:e6</to> </range> <range> <from>02:1A:4A:01:00:00</from> <to>02:1A:4A:FF:FF:FF</to> </range> </ranges> </mac_pool> ---- """ # Check the types of the parameters: Service._check_types([ ('pool', pool, types.MacPool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(pool, headers, query, wait) def permissions_service(self): """ Returns a reference to the service that manages the permissions that are associated with the MacPool. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'MacPoolService:%s' % self._path
View Source
def __init__(self, connection, path): super(MacPoolService, self).__init__(connection, path) self._permissions_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a MAC address pool. For example, to remove the MAC address pool having id `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/macpools/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes a MAC address pool.
For example, to remove the MAC address pool having id 123 send a request like this:
[source]
DELETE /ovirt-engine/api/macpools/123
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, pool, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a MAC address pool. The `name`, `description`, `allow_duplicates`, and `ranges` attributes can be updated. For example, to update the MAC address pool of id `123` send a request like this: [source] ---- PUT /ovirt-engine/api/macpools/123 ---- With a request body like this: [source,xml] ---- <mac_pool> <name>UpdatedMACPool</name> <description>An updated MAC address pool</description> <allow_duplicates>false</allow_duplicates> <ranges> <range> <from>00:1A:4A:16:01:51</from> <to>00:1A:4A:16:01:e6</to> </range> <range> <from>02:1A:4A:01:00:00</from> <to>02:1A:4A:FF:FF:FF</to> </range> </ranges> </mac_pool> ---- """ # Check the types of the parameters: Service._check_types([ ('pool', pool, types.MacPool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(pool, headers, query, wait)
Updates a MAC address pool.
The name, description, allow_duplicates, and ranges attributes can be updated.
For example, to update the MAC address pool of id 123 send a request like this:
[source]
PUT /ovirt-engine/api/macpools/123
With a request body like this:
[source,xml]
View Source
def permissions_service(self): """ Returns a reference to the service that manages the permissions that are associated with the MacPool. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
Returns a reference to the service that manages the permissions that are associated with the MacPool.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class MacPoolsService(Service): """ """ def __init__(self, connection, path): super(MacPoolsService, self).__init__(connection, path) self._mac_pool_service = None def add( self, pool, headers=None, query=None, wait=True, **kwargs ): """ Creates a new MAC address pool. Creation of a MAC address pool requires values for the `name` and `ranges` attributes. For example, to create MAC address pool send a request like this: [source] ---- POST /ovirt-engine/api/macpools ---- With a request body like this: [source,xml] ---- <mac_pool> <name>MACPool</name> <description>A MAC address pool</description> <allow_duplicates>true</allow_duplicates> <default_pool>false</default_pool> <ranges> <range> <from>00:1A:4A:16:01:51</from> <to>00:1A:4A:16:01:e6</to> </range> </ranges> </mac_pool> ---- """ # Check the types of the parameters: Service._check_types([ ('pool', pool, types.MacPool), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(pool, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Return the list of MAC address pools of the system. The returned list of MAC address pools isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of pools to return. If not specified all the pools are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def mac_pool_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return MacPoolService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.mac_pool_service(path) return self.mac_pool_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'MacPoolsService:%s' % self._path
View Source
def __init__(self, connection, path): super(MacPoolsService, self).__init__(connection, path) self._mac_pool_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, pool, headers=None, query=None, wait=True, **kwargs ): """ Creates a new MAC address pool. Creation of a MAC address pool requires values for the `name` and `ranges` attributes. For example, to create MAC address pool send a request like this: [source] ---- POST /ovirt-engine/api/macpools ---- With a request body like this: [source,xml] ---- <mac_pool> <name>MACPool</name> <description>A MAC address pool</description> <allow_duplicates>true</allow_duplicates> <default_pool>false</default_pool> <ranges> <range> <from>00:1A:4A:16:01:51</from> <to>00:1A:4A:16:01:e6</to> </range> </ranges> </mac_pool> ---- """ # Check the types of the parameters: Service._check_types([ ('pool', pool, types.MacPool), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(pool, headers, query, wait)
Creates a new MAC address pool.
Creation of a MAC address pool requires values for the name and ranges attributes.
For example, to create MAC address pool send a request like this:
[source]
POST /ovirt-engine/api/macpools
With a request body like this:
[source,xml]
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Return the list of MAC address pools of the system. The returned list of MAC address pools isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of pools to return. If not specified all the pools are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Return the list of MAC address pools of the system. The returned list of MAC address pools isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of pools to return. If not specified all the pools are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def mac_pool_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return MacPoolService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.mac_pool_service(path) return self.mac_pool_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class MeasurableService(Service): """ """ def __init__(self, connection, path): super(MeasurableService, self).__init__(connection, path) self._statistics_service = None def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'MeasurableService:%s' % self._path
View Source
def __init__(self, connection, path): super(MeasurableService, self).__init__(connection, path) self._statistics_service = None
Creates a new service that will use the given connection and path.
View Source
def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class MoveableService(Service): """ """ def __init__(self, connection, path): super(MoveableService, self).__init__(connection, path) def move( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the move should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'MoveableService:%s' % self._path
View Source
def __init__(self, connection, path): super(MoveableService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def move( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the move should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the move should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class NetworkService(Service): """ A service managing a network """ def __init__(self, connection, path): super(NetworkService, self).__init__(connection, path) self._network_labels_service = None self._permissions_service = None self._vnic_profiles_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets a logical network. For example: [source] ---- GET /ovirt-engine/api/networks/123 ---- Will respond: [source,xml] ---- <network href="/ovirt-engine/api/networks/123" id="123"> <name>ovirtmgmt</name> <description>Default Management Network</description> <link href="/ovirt-engine/api/networks/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/networks/123/vnicprofiles" rel="vnicprofiles"/> <link href="/ovirt-engine/api/networks/123/networklabels" rel="networklabels"/> <mtu>0</mtu> <stp>false</stp> <usages> <usage>vm</usage> </usages> <data_center href="/ovirt-engine/api/datacenters/456" id="456"/> </network> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a logical network, or the association of a logical network to a data center. For example, to remove the logical network `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/networks/123 ---- Each network is bound exactly to one data center. So if we disassociate network with data center it has the same result as if we would just remove that network. However it might be more specific to say we're removing network `456` of data center `123`. For example, to remove the association of network `456` to data center `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/datacenters/123/networks/456 ---- NOTE: To remove an external logical network, the network has to be removed directly from its provider by https://developer.openstack.org/api-ref/network[OpenStack Networking API]. The entity representing the external network inside {product-name} is removed automatically, if <<types/open_stack_network_provider/attributes/auto_sync,`auto_sync`>> is enabled for the provider, otherwise the entity has to be removed using this method. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, network, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a logical network. The `name`, `description`, `ip`, `vlan`, `stp` and `display` attributes can be updated. For example, to update the description of the logical network `123` send a request like this: [source] ---- PUT /ovirt-engine/api/networks/123 ---- With a request body like this: [source,xml] ---- <network> <description>My updated description</description> </network> ---- The maximum transmission unit of a network is set using a PUT request to specify the integer value of the `mtu` attribute. For example, to set the maximum transmission unit send a request like this: [source] ---- PUT /ovirt-engine/api/datacenters/123/networks/456 ---- With a request body like this: [source,xml] ---- <network> <mtu>1500</mtu> </network> ---- NOTE: Updating external networks is not propagated to the provider. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(network, headers, query, wait) def network_labels_service(self): """ Reference to the service that manages the network labels assigned to this network. """ return NetworkLabelsService(self._connection, '%s/networklabels' % self._path) def permissions_service(self): """ Reference to the service that manages the permissions assigned to this network. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def vnic_profiles_service(self): """ Reference to the service that manages the vNIC profiles assigned to this network. """ return AssignedVnicProfilesService(self._connection, '%s/vnicprofiles' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'networklabels': return self.network_labels_service() if path.startswith('networklabels/'): return self.network_labels_service().service(path[14:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'vnicprofiles': return self.vnic_profiles_service() if path.startswith('vnicprofiles/'): return self.vnic_profiles_service().service(path[13:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'NetworkService:%s' % self._path
A service managing a network
View Source
def __init__(self, connection, path): super(NetworkService, self).__init__(connection, path) self._network_labels_service = None self._permissions_service = None self._vnic_profiles_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets a logical network. For example: [source] ---- GET /ovirt-engine/api/networks/123 ---- Will respond: [source,xml] ---- <network href="/ovirt-engine/api/networks/123" id="123"> <name>ovirtmgmt</name> <description>Default Management Network</description> <link href="/ovirt-engine/api/networks/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/networks/123/vnicprofiles" rel="vnicprofiles"/> <link href="/ovirt-engine/api/networks/123/networklabels" rel="networklabels"/> <mtu>0</mtu> <stp>false</stp> <usages> <usage>vm</usage> </usages> <data_center href="/ovirt-engine/api/datacenters/456" id="456"/> </network> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets a logical network. For example:
[source]
GET /ovirt-engine/api/networks/123
Will respond:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a logical network, or the association of a logical network to a data center. For example, to remove the logical network `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/networks/123 ---- Each network is bound exactly to one data center. So if we disassociate network with data center it has the same result as if we would just remove that network. However it might be more specific to say we're removing network `456` of data center `123`. For example, to remove the association of network `456` to data center `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/datacenters/123/networks/456 ---- NOTE: To remove an external logical network, the network has to be removed directly from its provider by https://developer.openstack.org/api-ref/network[OpenStack Networking API]. The entity representing the external network inside {product-name} is removed automatically, if <<types/open_stack_network_provider/attributes/auto_sync,`auto_sync`>> is enabled for the provider, otherwise the entity has to be removed using this method. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes a logical network, or the association of a logical network to a data center.
For example, to remove the logical network 123 send a request like this:
[source]
DELETE /ovirt-engine/api/networks/123
Each network is bound exactly to one data center. So if we disassociate network with data center it has the same
result as if we would just remove that network. However it might be more specific to say we're removing network
456 of data center 123.
For example, to remove the association of network 456 to data center 123 send a request like this:
[source]
DELETE /ovirt-engine/api/datacenters/123/networks/456
NOTE: To remove an external logical network, the network has to be removed directly from its provider by
https://developer.openstack.org/api-ref/network[OpenStack Networking API].
The entity representing the external network inside {product-name} is removed automatically,
if <
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, network, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a logical network. The `name`, `description`, `ip`, `vlan`, `stp` and `display` attributes can be updated. For example, to update the description of the logical network `123` send a request like this: [source] ---- PUT /ovirt-engine/api/networks/123 ---- With a request body like this: [source,xml] ---- <network> <description>My updated description</description> </network> ---- The maximum transmission unit of a network is set using a PUT request to specify the integer value of the `mtu` attribute. For example, to set the maximum transmission unit send a request like this: [source] ---- PUT /ovirt-engine/api/datacenters/123/networks/456 ---- With a request body like this: [source,xml] ---- <network> <mtu>1500</mtu> </network> ---- NOTE: Updating external networks is not propagated to the provider. """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(network, headers, query, wait)
Updates a logical network.
The name, description, ip, vlan, stp and display attributes can be updated.
For example, to update the description of the logical network 123 send a request like this:
[source]
PUT /ovirt-engine/api/networks/123
With a request body like this:
[source,xml]
The maximum transmission unit of a network is set using a PUT request to
specify the integer value of the mtu attribute.
For example, to set the maximum transmission unit send a request like this:
[source]
PUT /ovirt-engine/api/datacenters/123/networks/456
With a request body like this:
[source,xml]
NOTE: Updating external networks is not propagated to the provider.
View Source
def network_labels_service(self): """ Reference to the service that manages the network labels assigned to this network. """ return NetworkLabelsService(self._connection, '%s/networklabels' % self._path)
Reference to the service that manages the network labels assigned to this network.
View Source
def permissions_service(self): """ Reference to the service that manages the permissions assigned to this network. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
Reference to the service that manages the permissions assigned to this network.
View Source
def vnic_profiles_service(self): """ Reference to the service that manages the vNIC profiles assigned to this network. """ return AssignedVnicProfilesService(self._connection, '%s/vnicprofiles' % self._path)
Reference to the service that manages the vNIC profiles assigned to this network.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'networklabels': return self.network_labels_service() if path.startswith('networklabels/'): return self.network_labels_service().service(path[14:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'vnicprofiles': return self.vnic_profiles_service() if path.startswith('vnicprofiles/'): return self.vnic_profiles_service().service(path[13:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class NetworkAttachmentService(Service): """ """ def __init__(self, connection, path): super(NetworkAttachmentService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, attachment, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified network attachment on the host. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.NetworkAttachment), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(attachment, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'NetworkAttachmentService:%s' % self._path
View Source
def __init__(self, connection, path): super(NetworkAttachmentService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, attachment, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified network attachment on the host. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.NetworkAttachment), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(attachment, headers, query, wait)
Update the specified network attachment on the host.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class NetworkAttachmentsService(Service): """ Manages the set of network attachments of a host or host NIC. """ def __init__(self, connection, path): super(NetworkAttachmentsService, self).__init__(connection, path) self._attachment_service = None def add( self, attachment, headers=None, query=None, wait=True, **kwargs ): """ Add a new network attachment to the network interface. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.NetworkAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(attachment, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of network attachments of the host or host NIC. The order of the returned list of network attachments isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of attachments to return. If not specified all the attachments are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def attachment_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return NetworkAttachmentService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.attachment_service(path) return self.attachment_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'NetworkAttachmentsService:%s' % self._path
Manages the set of network attachments of a host or host NIC.
View Source
def __init__(self, connection, path): super(NetworkAttachmentsService, self).__init__(connection, path) self._attachment_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, attachment, headers=None, query=None, wait=True, **kwargs ): """ Add a new network attachment to the network interface. """ # Check the types of the parameters: Service._check_types([ ('attachment', attachment, types.NetworkAttachment), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(attachment, headers, query, wait)
Add a new network attachment to the network interface.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of network attachments of the host or host NIC. The order of the returned list of network attachments isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of attachments to return. If not specified all the attachments are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of network attachments of the host or host NIC. The order of the returned list of network attachments isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of attachments to return. If not specified all the attachments are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def attachment_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return NetworkAttachmentService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.attachment_service(path) return self.attachment_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class NetworkFilterService(Service): """ Manages a network filter. [source,xml] ---- <network_filter id="00000019-0019-0019-0019-00000000026b"> <name>example-network-filter-b</name> <version> <major>4</major> <minor>0</minor> <build>-1</build> <revision>-1</revision> </version> </network_filter> ---- Please note that version is referring to the minimal support version for the specific filter. """ def __init__(self, connection, path): super(NetworkFilterService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a representation of the network filter. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'NetworkFilterService:%s' % self._path
Manages a network filter.
[source,xml]
Please note that version is referring to the minimal support version for the specific filter.
View Source
def __init__(self, connection, path): super(NetworkFilterService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a representation of the network filter. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves a representation of the network filter.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class NetworkFiltersService(Service): """ Represents a readonly network filters sub-collection. The network filter enables to filter packets send to/from the VM's nic according to defined rules. For more information please refer to <<services/network_filter,NetworkFilter>> service documentation Network filters are supported in different versions, starting from version 3.0. A network filter is defined for each vnic profile. A vnic profile is defined for a specific network. A network can be assigned to several different clusters. In the future, each network will be defined in cluster level. Currently, each network is being defined at data center level. Potential network filters for each network are determined by the network's data center compatibility version V. V must be >= the network filter version in order to configure this network filter for a specific network. Please note, that if a network is assigned to cluster with a version supporting a network filter, the filter may not be available due to the data center version being smaller then the network filter's version. Example of listing all of the supported network filters for a specific cluster: [source] ---- GET http://localhost:8080/ovirt-engine/api/clusters/{cluster:id}/networkfilters ---- Output: [source,xml] ---- <network_filters> <network_filter id="00000019-0019-0019-0019-00000000026c"> <name>example-network-filter-a</name> <version> <major>4</major> <minor>0</minor> <build>-1</build> <revision>-1</revision> </version> </network_filter> <network_filter id="00000019-0019-0019-0019-00000000026b"> <name>example-network-filter-b</name> <version> <major>4</major> <minor>0</minor> <build>-1</build> <revision>-1</revision> </version> </network_filter> <network_filter id="00000019-0019-0019-0019-00000000026a"> <name>example-network-filter-a</name> <version> <major>3</major> <minor>0</minor> <build>-1</build> <revision>-1</revision> </version> </network_filter> </network_filters> ---- """ def __init__(self, connection, path): super(NetworkFiltersService, self).__init__(connection, path) self._network_filter_service = None def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representations of the network filters. The order of the returned list of network filters isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def network_filter_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return NetworkFilterService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_filter_service(path) return self.network_filter_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'NetworkFiltersService:%s' % self._path
Represents a readonly network filters sub-collection.
The network filter enables to filter packets send to/from the VM's nic according to defined rules.
For more information please refer to <
[source]
GET http://localhost:8080/ovirt-engine/api/clusters/{cluster:id}/networkfilters
Output:
[source,xml]
View Source
def __init__(self, connection, path): super(NetworkFiltersService, self).__init__(connection, path) self._network_filter_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representations of the network filters. The order of the returned list of network filters isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the representations of the network filters. The order of the returned list of network filters isn't guaranteed.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def network_filter_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return NetworkFilterService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_filter_service(path) return self.network_filter_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class NetworkLabelService(Service): """ """ def __init__(self, connection, path): super(NetworkLabelService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a label from a logical network. For example, to remove the label `exemplary` from a logical network having id `123` send the following request: [source] ---- DELETE /ovirt-engine/api/networks/123/networklabels/exemplary ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'NetworkLabelService:%s' % self._path
View Source
def __init__(self, connection, path): super(NetworkLabelService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a label from a logical network. For example, to remove the label `exemplary` from a logical network having id `123` send the following request: [source] ---- DELETE /ovirt-engine/api/networks/123/networklabels/exemplary ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes a label from a logical network.
For example, to remove the label exemplary from a logical network having id 123 send the following request:
[source]
DELETE /ovirt-engine/api/networks/123/networklabels/exemplary
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class NetworkLabelsService(Service): """ Manages the ser of labels attached to a network or to a host NIC. """ def __init__(self, connection, path): super(NetworkLabelsService, self).__init__(connection, path) self._label_service = None def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Attaches label to logical network. You can attach labels to a logical network to automate the association of that logical network with physical host network interfaces to which the same label has been attached. For example, to attach the label `mylabel` to a logical network having id `123` send a request like this: [source] ---- POST /ovirt-engine/api/networks/123/networklabels ---- With a request body like this: [source,xml] ---- <network_label id="mylabel"/> ---- """ # Check the types of the parameters: Service._check_types([ ('label', label, types.NetworkLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of labels attached to the network or host NIC. The order of the returned list of labels isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of labels to return. If not specified all the labels are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def label_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return NetworkLabelService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'NetworkLabelsService:%s' % self._path
Manages the ser of labels attached to a network or to a host NIC.
View Source
def __init__(self, connection, path): super(NetworkLabelsService, self).__init__(connection, path) self._label_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, label, headers=None, query=None, wait=True, **kwargs ): """ Attaches label to logical network. You can attach labels to a logical network to automate the association of that logical network with physical host network interfaces to which the same label has been attached. For example, to attach the label `mylabel` to a logical network having id `123` send a request like this: [source] ---- POST /ovirt-engine/api/networks/123/networklabels ---- With a request body like this: [source,xml] ---- <network_label id="mylabel"/> ---- """ # Check the types of the parameters: Service._check_types([ ('label', label, types.NetworkLabel), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(label, headers, query, wait)
Attaches label to logical network.
You can attach labels to a logical network to automate the association of that logical network with physical host
network interfaces to which the same label has been attached.
For example, to attach the label mylabel to a logical network having id 123 send a request like this:
[source]
POST /ovirt-engine/api/networks/123/networklabels
With a request body like this:
[source,xml]
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of labels attached to the network or host NIC. The order of the returned list of labels isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of labels to return. If not specified all the labels are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of labels attached to the network or host NIC. The order of the returned list of labels isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of labels to return. If not specified all the labels are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def label_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return NetworkLabelService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.label_service(path) return self.label_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class NetworksService(Service): """ Manages logical networks. The engine creates a default `ovirtmgmt` network on installation. This network acts as the management network for access to hypervisor hosts. This network is associated with the `Default` cluster and is a member of the `Default` data center. """ def __init__(self, connection, path): super(NetworksService, self).__init__(connection, path) self._network_service = None def add( self, network, headers=None, query=None, wait=True, **kwargs ): """ Creates a new logical network, or associates an existing network with a data center. Creation of a new network requires the `name` and `data_center` elements. For example, to create a network named `mynetwork` for data center `123` send a request like this: [source] ---- POST /ovirt-engine/api/networks ---- With a request body like this: [source,xml] ---- <network> <name>mynetwork</name> <data_center id="123"/> </network> ---- To associate the existing network `456` with the data center `123` send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/networks ---- With a request body like this: [source,xml] ---- <network> <name>ovirtmgmt</name> </network> ---- To create a network named `exnetwork` on top of an external _OpenStack_ network provider `456` send a request like this: [source] ---- POST /ovirt-engine/api/networks ---- [source,xml] ---- <network> <name>exnetwork</name> <external_provider id="456"/> <data_center id="123"/> </network> ---- """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(network, headers, query, wait) def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ List logical networks. For example: [source] ---- GET /ovirt-engine/api/networks ---- Will respond: [source,xml] ---- <networks> <network href="/ovirt-engine/api/networks/123" id="123"> <name>ovirtmgmt</name> <description>Default Management Network</description> <link href="/ovirt-engine/api/networks/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/networks/123/vnicprofiles" rel="vnicprofiles"/> <link href="/ovirt-engine/api/networks/123/networklabels" rel="networklabels"/> <mtu>0</mtu> <stp>false</stp> <usages> <usage>vm</usage> </usages> <data_center href="/ovirt-engine/api/datacenters/456" id="456"/> </network> ... </networks> ---- The order of the returned list of networks is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `search`:: A query string used to restrict the returned networks. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def network_service(self, id): """ Reference to the service that manages a specific network. """ Service._check_types([ ('id', id, str), ]) return NetworkService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'NetworksService:%s' % self._path
Manages logical networks.
The engine creates a default ovirtmgmt network on installation. This network acts as the management network for
access to hypervisor hosts. This network is associated with the Default cluster and is a member of the Default
data center.
View Source
def __init__(self, connection, path): super(NetworksService, self).__init__(connection, path) self._network_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, network, headers=None, query=None, wait=True, **kwargs ): """ Creates a new logical network, or associates an existing network with a data center. Creation of a new network requires the `name` and `data_center` elements. For example, to create a network named `mynetwork` for data center `123` send a request like this: [source] ---- POST /ovirt-engine/api/networks ---- With a request body like this: [source,xml] ---- <network> <name>mynetwork</name> <data_center id="123"/> </network> ---- To associate the existing network `456` with the data center `123` send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/networks ---- With a request body like this: [source,xml] ---- <network> <name>ovirtmgmt</name> </network> ---- To create a network named `exnetwork` on top of an external _OpenStack_ network provider `456` send a request like this: [source] ---- POST /ovirt-engine/api/networks ---- [source,xml] ---- <network> <name>exnetwork</name> <external_provider id="456"/> <data_center id="123"/> </network> ---- """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(network, headers, query, wait)
Creates a new logical network, or associates an existing network with a data center.
Creation of a new network requires the name and data_center elements.
For example, to create a network named mynetwork for data center 123 send a request like this:
[source]
POST /ovirt-engine/api/networks
With a request body like this:
[source,xml]
To associate the existing network 456 with the data center 123 send a request like this:
[source]
POST /ovirt-engine/api/datacenters/123/networks
With a request body like this:
[source,xml]
To create a network named exnetwork on top of an external _OpenStack_ network provider 456 send a request
like this:
[source]
POST /ovirt-engine/api/networks
[source,xml]
#
def
list(
self,
case_sensitive=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ List logical networks. For example: [source] ---- GET /ovirt-engine/api/networks ---- Will respond: [source,xml] ---- <networks> <network href="/ovirt-engine/api/networks/123" id="123"> <name>ovirtmgmt</name> <description>Default Management Network</description> <link href="/ovirt-engine/api/networks/123/permissions" rel="permissions"/> <link href="/ovirt-engine/api/networks/123/vnicprofiles" rel="vnicprofiles"/> <link href="/ovirt-engine/api/networks/123/networklabels" rel="networklabels"/> <mtu>0</mtu> <stp>false</stp> <usages> <usage>vm</usage> </usages> <data_center href="/ovirt-engine/api/datacenters/456" id="456"/> </network> ... </networks> ---- The order of the returned list of networks is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `search`:: A query string used to restrict the returned networks. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List logical networks. For example:
[source]
GET /ovirt-engine/api/networks
Will respond:
[source,xml]
The order of the returned list of networks is guaranteed only if the sortby clause is included in the
search parameter.
This method supports the following parameters:
max:: Sets the maximum number of networks to return. If not specified all the networks are returned.
search:: A query string used to restrict the returned networks.
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def network_service(self, id): """ Reference to the service that manages a specific network. """ Service._check_types([ ('id', id, str), ]) return NetworkService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages a specific network.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class NicNetworkFilterParameterService(Service): """ This service manages a parameter for a network filter. """ def __init__(self, connection, path): super(NicNetworkFilterParameterService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a representation of the network filter parameter. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes the filter parameter. For example, to remove the filter parameter with id `123` on NIC `456` of virtual machine `789` send a request like this: [source] ---- DELETE /ovirt-engine/api/vms/789/nics/456/networkfilterparameters/123 ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, parameter, headers=None, query=None, wait=True, **kwargs ): """ Updates the network filter parameter. For example, to update the network filter parameter having with with id `123` on NIC `456` of virtual machine `789` send a request like this: [source] ---- PUT /ovirt-engine/api/vms/789/nics/456/networkfilterparameters/123 ---- With a request body like this: [source,xml] ---- <network_filter_parameter> <name>updatedName</name> <value>updatedValue</value> </network_filter_parameter> ---- This method supports the following parameters: `parameter`:: The network filter parameter that is being updated. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('parameter', parameter, types.NetworkFilterParameter), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(parameter, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'NicNetworkFilterParameterService:%s' % self._path
This service manages a parameter for a network filter.
View Source
def __init__(self, connection, path): super(NicNetworkFilterParameterService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a representation of the network filter parameter. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves a representation of the network filter parameter.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes the filter parameter. For example, to remove the filter parameter with id `123` on NIC `456` of virtual machine `789` send a request like this: [source] ---- DELETE /ovirt-engine/api/vms/789/nics/456/networkfilterparameters/123 ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the filter parameter.
For example, to remove the filter parameter with id 123 on NIC 456 of virtual machine 789
send a request like this:
[source]
DELETE /ovirt-engine/api/vms/789/nics/456/networkfilterparameters/123
View Source
def update( self, parameter, headers=None, query=None, wait=True, **kwargs ): """ Updates the network filter parameter. For example, to update the network filter parameter having with with id `123` on NIC `456` of virtual machine `789` send a request like this: [source] ---- PUT /ovirt-engine/api/vms/789/nics/456/networkfilterparameters/123 ---- With a request body like this: [source,xml] ---- <network_filter_parameter> <name>updatedName</name> <value>updatedValue</value> </network_filter_parameter> ---- This method supports the following parameters: `parameter`:: The network filter parameter that is being updated. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('parameter', parameter, types.NetworkFilterParameter), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(parameter, headers, query, wait)
Updates the network filter parameter.
For example, to update the network filter parameter having with with id 123 on NIC 456 of
virtual machine 789 send a request like this:
[source]
PUT /ovirt-engine/api/vms/789/nics/456/networkfilterparameters/123
With a request body like this:
[source,xml]
This method supports the following parameters:
parameter:: The network filter parameter that is being updated.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class NicNetworkFilterParametersService(Service): """ This service manages a collection of parameters for network filters. """ def __init__(self, connection, path): super(NicNetworkFilterParametersService, self).__init__(connection, path) self._parameter_service = None def add( self, parameter, headers=None, query=None, wait=True, **kwargs ): """ Add a network filter parameter. For example, to add the parameter for the network filter on NIC `456` of virtual machine `789` send a request like this: [source] ---- POST /ovirt-engine/api/vms/789/nics/456/networkfilterparameters ---- With a request body like this: [source,xml] ---- <network_filter_parameter> <name>IP</name> <value>10.0.1.2</value> </network_filter_parameter> ---- This method supports the following parameters: `parameter`:: The network filter parameter that is being added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('parameter', parameter, types.NetworkFilterParameter), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(parameter, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representations of the network filter parameters. The order of the returned list of network filters isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def parameter_service(self, id): """ Reference to the service that manages a specific network filter parameter. """ Service._check_types([ ('id', id, str), ]) return NicNetworkFilterParameterService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.parameter_service(path) return self.parameter_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'NicNetworkFilterParametersService:%s' % self._path
This service manages a collection of parameters for network filters.
View Source
def __init__(self, connection, path): super(NicNetworkFilterParametersService, self).__init__(connection, path) self._parameter_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, parameter, headers=None, query=None, wait=True, **kwargs ): """ Add a network filter parameter. For example, to add the parameter for the network filter on NIC `456` of virtual machine `789` send a request like this: [source] ---- POST /ovirt-engine/api/vms/789/nics/456/networkfilterparameters ---- With a request body like this: [source,xml] ---- <network_filter_parameter> <name>IP</name> <value>10.0.1.2</value> </network_filter_parameter> ---- This method supports the following parameters: `parameter`:: The network filter parameter that is being added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('parameter', parameter, types.NetworkFilterParameter), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(parameter, headers, query, wait)
Add a network filter parameter.
For example, to add the parameter for the network filter on NIC 456 of
virtual machine 789 send a request like this:
[source]
POST /ovirt-engine/api/vms/789/nics/456/networkfilterparameters
With a request body like this:
[source,xml]
This method supports the following parameters:
parameter:: The network filter parameter that is being added.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representations of the network filter parameters. The order of the returned list of network filters isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the representations of the network filter parameters. The order of the returned list of network filters isn't guaranteed.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def parameter_service(self, id): """ Reference to the service that manages a specific network filter parameter. """ Service._check_types([ ('id', id, str), ]) return NicNetworkFilterParameterService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages a specific network filter parameter.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.parameter_service(path) return self.parameter_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackImageService(Service): """ """ def __init__(self, connection, path): super(OpenstackImageService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_( self, async_=None, cluster=None, disk=None, import_as_template=None, storage_domain=None, template=None, headers=None, query=None, wait=True, **kwargs ): """ Imports a virtual machine from a Glance image storage domain. For example, to import the image with identifier `456` from the storage domain with identifier `123` send a request like this: [source] ---- POST /ovirt-engine/api/openstackimageproviders/123/images/456/import ---- With a request body like this: [source,xml] ---- <action> <storage_domain> <name>images0</name> </storage_domain> <cluster> <name>images0</name> </cluster> </action> ---- This method supports the following parameters: `import_as_template`:: Indicates whether the image should be imported as a template. `cluster`:: This parameter is mandatory in case of using `import_as_template` and indicates which cluster should be used for import glance image as template. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('disk', disk, types.Disk), ('import_as_template', import_as_template, bool), ('storage_domain', storage_domain, types.StorageDomain), ('template', template, types.Template), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, cluster=cluster, disk=disk, import_as_template=import_as_template, storage_domain=storage_domain, template=template, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackImageService:%s' % self._path
View Source
def __init__(self, connection, path): super(OpenstackImageService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
import_(
self,
async_=None,
cluster=None,
disk=None,
import_as_template=None,
storage_domain=None,
template=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def import_( self, async_=None, cluster=None, disk=None, import_as_template=None, storage_domain=None, template=None, headers=None, query=None, wait=True, **kwargs ): """ Imports a virtual machine from a Glance image storage domain. For example, to import the image with identifier `456` from the storage domain with identifier `123` send a request like this: [source] ---- POST /ovirt-engine/api/openstackimageproviders/123/images/456/import ---- With a request body like this: [source,xml] ---- <action> <storage_domain> <name>images0</name> </storage_domain> <cluster> <name>images0</name> </cluster> </action> ---- This method supports the following parameters: `import_as_template`:: Indicates whether the image should be imported as a template. `cluster`:: This parameter is mandatory in case of using `import_as_template` and indicates which cluster should be used for import glance image as template. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('disk', disk, types.Disk), ('import_as_template', import_as_template, bool), ('storage_domain', storage_domain, types.StorageDomain), ('template', template, types.Template), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, cluster=cluster, disk=disk, import_as_template=import_as_template, storage_domain=storage_domain, template=template, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait)
Imports a virtual machine from a Glance image storage domain.
For example, to import the image with identifier 456 from the
storage domain with identifier 123 send a request like this:
[source]
POST /ovirt-engine/api/openstackimageproviders/123/images/456/import
With a request body like this:
[source,xml]
This method supports the following parameters:
import_as_template:: Indicates whether the image should be imported as a template.
cluster:: This parameter is mandatory in case of using import_as_template and indicates which cluster should be used
for import glance image as template.
async_:: Indicates if the import should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackImageProviderService(ExternalProviderService): """ """ def __init__(self, connection, path): super(OpenstackImageProviderService, self).__init__(connection, path) self._certificates_service = None self._images_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait) def update( self, provider, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified OpenStack image provider in the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackImageProvider), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(provider, headers, query, wait) def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path) def images_service(self): """ """ return OpenstackImagesService(self._connection, '%s/images' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) if path == 'images': return self.images_service() if path.startswith('images/'): return self.images_service().service(path[7:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackImageProviderService:%s' % self._path
View Source
def __init__(self, connection, path): super(OpenstackImageProviderService, self).__init__(connection, path) self._certificates_service = None self._images_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
import_certificates(
self,
certificates=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait)
Import the SSL certificates of the external host provider.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait)
In order to test connectivity for external provider we need to run following request where 123 is an id of a provider.
[source]
POST /ovirt-engine/api/externalhostproviders/123/testconnectivity
This method supports the following parameters:
async_:: Indicates if the test should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, provider, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified OpenStack image provider in the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackImageProvider), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(provider, headers, query, wait)
Update the specified OpenStack image provider in the system.
View Source
def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path)
A service to view certificates for this external provider.
View Source
def images_service(self): """ """ return OpenstackImagesService(self._connection, '%s/images' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) if path == 'images': return self.images_service() if path.startswith('images/'): return self.images_service().service(path[7:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackImageProvidersService(Service): """ """ def __init__(self, connection, path): super(OpenstackImageProvidersService, self).__init__(connection, path) self._provider_service = None def add( self, provider, headers=None, query=None, wait=True, **kwargs ): """ Add a new OpenStack image provider to the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackImageProvider), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(provider, headers, query, wait) def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of providers. The order of the returned list of providers isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of providers to return. If not specified all the providers are returned. `search`:: A query string used to restrict the returned OpenStack image providers. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def provider_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackImageProviderService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.provider_service(path) return self.provider_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackImageProvidersService:%s' % self._path
View Source
def __init__(self, connection, path): super(OpenstackImageProvidersService, self).__init__(connection, path) self._provider_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, provider, headers=None, query=None, wait=True, **kwargs ): """ Add a new OpenStack image provider to the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackImageProvider), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(provider, headers, query, wait)
Add a new OpenStack image provider to the system.
#
def
list(
self,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of providers. The order of the returned list of providers isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of providers to return. If not specified all the providers are returned. `search`:: A query string used to restrict the returned OpenStack image providers. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of providers. The order of the returned list of providers isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of providers to return. If not specified all the providers are returned.
search:: A query string used to restrict the returned OpenStack image providers.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def provider_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackImageProviderService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.provider_service(path) return self.provider_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackImagesService(Service): """ """ def __init__(self, connection, path): super(OpenstackImagesService, self).__init__(connection, path) self._image_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the images of a Glance image storage domain. The order of the returned list of images isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of images to return. If not specified all the images are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def image_service(self, id): """ Returns a reference to the service that manages a specific image. """ Service._check_types([ ('id', id, str), ]) return OpenstackImageService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.image_service(path) return self.image_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackImagesService:%s' % self._path
View Source
def __init__(self, connection, path): super(OpenstackImagesService, self).__init__(connection, path) self._image_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists the images of a Glance image storage domain. The order of the returned list of images isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of images to return. If not specified all the images are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists the images of a Glance image storage domain. The order of the returned list of images isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of images to return. If not specified all the images are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def image_service(self, id): """ Returns a reference to the service that manages a specific image. """ Service._check_types([ ('id', id, str), ]) return OpenstackImageService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service that manages a specific image.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.image_service(path) return self.image_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackNetworkService(Service): """ """ def __init__(self, connection, path): super(OpenstackNetworkService, self).__init__(connection, path) self._subnets_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_( self, async_=None, data_center=None, headers=None, query=None, wait=True, **kwargs ): """ This operation imports an external network into {product-name}. The network will be added to the specified data center. This method supports the following parameters: `data_center`:: The data center into which the network is to be imported. Data center is mandatory, and can be specified using the `id` or `name` attributes. The rest of the attributes will be ignored. NOTE: If <<types/open_stack_network_provider/attributes/auto_sync,`auto_sync`>> is enabled for the provider, the network might be imported automatically. To prevent this, automatic import can be disabled by setting the `auto_sync` to false, and enabling it again after importing the network. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('data_center', data_center, types.DataCenter), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, data_center=data_center, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait) def subnets_service(self): """ """ return OpenstackSubnetsService(self._connection, '%s/subnets' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'subnets': return self.subnets_service() if path.startswith('subnets/'): return self.subnets_service().service(path[8:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackNetworkService:%s' % self._path
View Source
def __init__(self, connection, path): super(OpenstackNetworkService, self).__init__(connection, path) self._subnets_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
import_(
self,
async_=None,
data_center=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def import_( self, async_=None, data_center=None, headers=None, query=None, wait=True, **kwargs ): """ This operation imports an external network into {product-name}. The network will be added to the specified data center. This method supports the following parameters: `data_center`:: The data center into which the network is to be imported. Data center is mandatory, and can be specified using the `id` or `name` attributes. The rest of the attributes will be ignored. NOTE: If <<types/open_stack_network_provider/attributes/auto_sync,`auto_sync`>> is enabled for the provider, the network might be imported automatically. To prevent this, automatic import can be disabled by setting the `auto_sync` to false, and enabling it again after importing the network. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('data_center', data_center, types.DataCenter), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, data_center=data_center, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait)
This operation imports an external network into {product-name}. The network will be added to the specified data center.
This method supports the following parameters:
data_center:: The data center into which the network is to be imported.
Data center is mandatory, and can be specified
using the id or name attributes. The rest of
the attributes will be ignored.
NOTE: If <auto_sync to false,
and enabling it again after importing the network.
async_:: Indicates if the import should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def subnets_service(self): """ """ return OpenstackSubnetsService(self._connection, '%s/subnets' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'subnets': return self.subnets_service() if path.startswith('subnets/'): return self.subnets_service().service(path[8:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackNetworkProviderService(ExternalProviderService): """ This service manages the OpenStack network provider. """ def __init__(self, connection, path): super(OpenstackNetworkProviderService, self).__init__(connection, path) self._certificates_service = None self._networks_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the representation of the object managed by this service. For example, to get the OpenStack network provider with identifier `1234`, send a request like this: [source] ---- GET /ovirt-engine/api/openstacknetworkproviders/1234 ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the provider. For example, to remove the OpenStack network provider with identifier `1234`, send a request like this: [source] ---- DELETE /ovirt-engine/api/openstacknetworkproviders/1234 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait) def update( self, provider, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the provider. For example, to update `provider_name`, `requires_authentication`, `url`, `tenant_name` and `type` properties, for the OpenStack network provider with identifier `1234`, send a request like this: [source] ---- PUT /ovirt-engine/api/openstacknetworkproviders/1234 ---- With a request body like this: [source,xml] ---- <openstack_network_provider> <name>ovn-network-provider</name> <requires_authentication>false</requires_authentication> <url>http://some_server_url.domain.com:9696</url> <tenant_name>oVirt</tenant_name> <type>external</type> </openstack_network_provider> ---- This method supports the following parameters: `provider`:: The provider to update. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackNetworkProvider), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(provider, headers, query, wait) def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path) def networks_service(self): """ Reference to OpenStack networks service. """ return OpenstackNetworksService(self._connection, '%s/networks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackNetworkProviderService:%s' % self._path
This service manages the OpenStack network provider.
View Source
def __init__(self, connection, path): super(OpenstackNetworkProviderService, self).__init__(connection, path) self._certificates_service = None self._networks_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the representation of the object managed by this service. For example, to get the OpenStack network provider with identifier `1234`, send a request like this: [source] ---- GET /ovirt-engine/api/openstacknetworkproviders/1234 ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the representation of the object managed by this service.
For example, to get the OpenStack network provider with identifier 1234, send a request like this:
[source]
GET /ovirt-engine/api/openstacknetworkproviders/1234
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
import_certificates(
self,
certificates=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait)
Import the SSL certificates of the external host provider.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the provider. For example, to remove the OpenStack network provider with identifier `1234`, send a request like this: [source] ---- DELETE /ovirt-engine/api/openstacknetworkproviders/1234 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the provider.
For example, to remove the OpenStack network provider with identifier 1234, send a request like this:
[source]
DELETE /ovirt-engine/api/openstacknetworkproviders/1234
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait)
In order to test connectivity for external provider we need to run following request where 123 is an id of a provider.
[source]
POST /ovirt-engine/api/externalhostproviders/123/testconnectivity
This method supports the following parameters:
async_:: Indicates if the test should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, provider, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the provider. For example, to update `provider_name`, `requires_authentication`, `url`, `tenant_name` and `type` properties, for the OpenStack network provider with identifier `1234`, send a request like this: [source] ---- PUT /ovirt-engine/api/openstacknetworkproviders/1234 ---- With a request body like this: [source,xml] ---- <openstack_network_provider> <name>ovn-network-provider</name> <requires_authentication>false</requires_authentication> <url>http://some_server_url.domain.com:9696</url> <tenant_name>oVirt</tenant_name> <type>external</type> </openstack_network_provider> ---- This method supports the following parameters: `provider`:: The provider to update. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackNetworkProvider), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(provider, headers, query, wait)
Updates the provider.
For example, to update provider_name, requires_authentication, url, tenant_name and type properties,
for the OpenStack network provider with identifier 1234, send a request like this:
[source]
PUT /ovirt-engine/api/openstacknetworkproviders/1234
With a request body like this:
[source,xml]
This method supports the following parameters:
provider:: The provider to update.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path)
A service to view certificates for this external provider.
View Source
def networks_service(self): """ Reference to OpenStack networks service. """ return OpenstackNetworksService(self._connection, '%s/networks' % self._path)
Reference to OpenStack networks service.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackNetworkProvidersService(Service): """ This service manages OpenStack network providers. """ def __init__(self, connection, path): super(OpenstackNetworkProvidersService, self).__init__(connection, path) self._provider_service = None def add( self, provider, headers=None, query=None, wait=True, **kwargs ): """ The operation adds a new network provider to the system. If the `type` property is not present, a default value of `NEUTRON` will be used. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackNetworkProvider), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(provider, headers, query, wait) def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of providers. The order of the returned list of providers isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of providers to return. If not specified all the providers are returned. `search`:: A query string used to restrict the returned OpenStack network providers. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def provider_service(self, id): """ Reference to OpenStack network provider service. """ Service._check_types([ ('id', id, str), ]) return OpenstackNetworkProviderService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.provider_service(path) return self.provider_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackNetworkProvidersService:%s' % self._path
This service manages OpenStack network providers.
View Source
def __init__(self, connection, path): super(OpenstackNetworkProvidersService, self).__init__(connection, path) self._provider_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, provider, headers=None, query=None, wait=True, **kwargs ): """ The operation adds a new network provider to the system. If the `type` property is not present, a default value of `NEUTRON` will be used. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackNetworkProvider), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(provider, headers, query, wait)
The operation adds a new network provider to the system.
If the type property is not present, a default value of NEUTRON will be used.
#
def
list(
self,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of providers. The order of the returned list of providers isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of providers to return. If not specified all the providers are returned. `search`:: A query string used to restrict the returned OpenStack network providers. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of providers. The order of the returned list of providers isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of providers to return. If not specified all the providers are returned.
search:: A query string used to restrict the returned OpenStack network providers.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def provider_service(self, id): """ Reference to OpenStack network provider service. """ Service._check_types([ ('id', id, str), ]) return OpenstackNetworkProviderService(self._connection, '%s/%s' % (self._path, id))
Reference to OpenStack network provider service.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.provider_service(path) return self.provider_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackNetworksService(Service): """ """ def __init__(self, connection, path): super(OpenstackNetworksService, self).__init__(connection, path) self._network_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of networks. The order of the returned list of networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def network_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackNetworkService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackNetworksService:%s' % self._path
View Source
def __init__(self, connection, path): super(OpenstackNetworksService, self).__init__(connection, path) self._network_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of networks. The order of the returned list of networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of networks. The order of the returned list of networks isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of networks to return. If not specified all the networks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def network_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackNetworkService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackSubnetService(Service): """ """ def __init__(self, connection, path): super(OpenstackSubnetService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackSubnetService:%s' % self._path
View Source
def __init__(self, connection, path): super(OpenstackSubnetService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackSubnetsService(Service): """ """ def __init__(self, connection, path): super(OpenstackSubnetsService, self).__init__(connection, path) self._subnet_service = None def add( self, subnet, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('subnet', subnet, types.OpenStackSubnet), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(subnet, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of sub-networks. The order of the returned list of sub-networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of sub-networks to return. If not specified all the sub-networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def subnet_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackSubnetService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.subnet_service(path) return self.subnet_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackSubnetsService:%s' % self._path
View Source
def __init__(self, connection, path): super(OpenstackSubnetsService, self).__init__(connection, path) self._subnet_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, subnet, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('subnet', subnet, types.OpenStackSubnet), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(subnet, headers, query, wait)
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of sub-networks. The order of the returned list of sub-networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of sub-networks to return. If not specified all the sub-networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of sub-networks. The order of the returned list of sub-networks isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of sub-networks to return. If not specified all the sub-networks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def subnet_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackSubnetService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.subnet_service(path) return self.subnet_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackVolumeAuthenticationKeyService(Service): """ """ def __init__(self, connection, path): super(OpenstackVolumeAuthenticationKeyService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, key, headers=None, query=None, wait=True, **kwargs ): """ Update the specified authentication key. """ # Check the types of the parameters: Service._check_types([ ('key', key, types.OpenstackVolumeAuthenticationKey), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(key, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackVolumeAuthenticationKeyService:%s' % self._path
View Source
def __init__(self, connection, path): super(OpenstackVolumeAuthenticationKeyService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, key, headers=None, query=None, wait=True, **kwargs ): """ Update the specified authentication key. """ # Check the types of the parameters: Service._check_types([ ('key', key, types.OpenstackVolumeAuthenticationKey), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(key, headers, query, wait)
Update the specified authentication key.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackVolumeAuthenticationKeysService(Service): """ """ def __init__(self, connection, path): super(OpenstackVolumeAuthenticationKeysService, self).__init__(connection, path) self._key_service = None def add( self, key, headers=None, query=None, wait=True, **kwargs ): """ Add a new authentication key to the OpenStack volume provider. """ # Check the types of the parameters: Service._check_types([ ('key', key, types.OpenstackVolumeAuthenticationKey), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(key, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of authentication keys. The order of the returned list of authentication keys isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of keys to return. If not specified all the keys are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def key_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackVolumeAuthenticationKeyService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.key_service(path) return self.key_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackVolumeAuthenticationKeysService:%s' % self._path
View Source
def __init__(self, connection, path): super(OpenstackVolumeAuthenticationKeysService, self).__init__(connection, path) self._key_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, key, headers=None, query=None, wait=True, **kwargs ): """ Add a new authentication key to the OpenStack volume provider. """ # Check the types of the parameters: Service._check_types([ ('key', key, types.OpenstackVolumeAuthenticationKey), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(key, headers, query, wait)
Add a new authentication key to the OpenStack volume provider.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of authentication keys. The order of the returned list of authentication keys isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of keys to return. If not specified all the keys are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of authentication keys. The order of the returned list of authentication keys isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of keys to return. If not specified all the keys are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def key_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackVolumeAuthenticationKeyService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.key_service(path) return self.key_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackVolumeProviderService(ExternalProviderService): """ """ def __init__(self, connection, path): super(OpenstackVolumeProviderService, self).__init__(connection, path) self._authentication_keys_service = None self._certificates_service = None self._volume_types_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait) def remove( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `force`:: Indicates if the operation should succeed, and the provider removed from the database, even if something fails during the operation. This parameter is optional, and the default value is `false`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: self._internal_remove(headers, query, wait) def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait) def update( self, provider, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified OpenStack volume provider in the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackVolumeProvider), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(provider, headers, query, wait) def authentication_keys_service(self): """ """ return OpenstackVolumeAuthenticationKeysService(self._connection, '%s/authenticationkeys' % self._path) def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path) def volume_types_service(self): """ """ return OpenstackVolumeTypesService(self._connection, '%s/volumetypes' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'authenticationkeys': return self.authentication_keys_service() if path.startswith('authenticationkeys/'): return self.authentication_keys_service().service(path[19:]) if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) if path == 'volumetypes': return self.volume_types_service() if path.startswith('volumetypes/'): return self.volume_types_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackVolumeProviderService:%s' % self._path
View Source
def __init__(self, connection, path): super(OpenstackVolumeProviderService, self).__init__(connection, path) self._authentication_keys_service = None self._certificates_service = None self._volume_types_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
import_certificates(
self,
certificates=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait)
Import the SSL certificates of the external host provider.
View Source
def remove( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `force`:: Indicates if the operation should succeed, and the provider removed from the database, even if something fails during the operation. This parameter is optional, and the default value is `false`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
force:: Indicates if the operation should succeed, and the provider removed from the database,
even if something fails during the operation.
This parameter is optional, and the default value is false.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait)
In order to test connectivity for external provider we need to run following request where 123 is an id of a provider.
[source]
POST /ovirt-engine/api/externalhostproviders/123/testconnectivity
This method supports the following parameters:
async_:: Indicates if the test should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, provider, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified OpenStack volume provider in the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackVolumeProvider), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(provider, headers, query, wait)
Update the specified OpenStack volume provider in the system.
View Source
def authentication_keys_service(self): """ """ return OpenstackVolumeAuthenticationKeysService(self._connection, '%s/authenticationkeys' % self._path)
View Source
def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path)
A service to view certificates for this external provider.
View Source
def volume_types_service(self): """ """ return OpenstackVolumeTypesService(self._connection, '%s/volumetypes' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'authenticationkeys': return self.authentication_keys_service() if path.startswith('authenticationkeys/'): return self.authentication_keys_service().service(path[19:]) if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) if path == 'volumetypes': return self.volume_types_service() if path.startswith('volumetypes/'): return self.volume_types_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackVolumeProvidersService(Service): """ """ def __init__(self, connection, path): super(OpenstackVolumeProvidersService, self).__init__(connection, path) self._provider_service = None def add( self, provider, headers=None, query=None, wait=True, **kwargs ): """ Adds a new volume provider. For example: [source] ---- POST /ovirt-engine/api/openstackvolumeproviders ---- With a request body like this: [source,xml] ---- <openstack_volume_provider> <name>mycinder</name> <url>https://mycinder.example.com:8776</url> <data_center> <name>mydc</name> </data_center> <requires_authentication>true</requires_authentication> <username>admin</username> <password>mypassword</password> <tenant_name>mytenant</tenant_name> </openstack_volume_provider> ---- """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackVolumeProvider), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(provider, headers, query, wait) def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the list of volume providers. The order of the returned list of volume providers isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of providers to return. If not specified all the providers are returned. `search`:: A query string used to restrict the returned volume providers. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def provider_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackVolumeProviderService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.provider_service(path) return self.provider_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackVolumeProvidersService:%s' % self._path
View Source
def __init__(self, connection, path): super(OpenstackVolumeProvidersService, self).__init__(connection, path) self._provider_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, provider, headers=None, query=None, wait=True, **kwargs ): """ Adds a new volume provider. For example: [source] ---- POST /ovirt-engine/api/openstackvolumeproviders ---- With a request body like this: [source,xml] ---- <openstack_volume_provider> <name>mycinder</name> <url>https://mycinder.example.com:8776</url> <data_center> <name>mydc</name> </data_center> <requires_authentication>true</requires_authentication> <username>admin</username> <password>mypassword</password> <tenant_name>mytenant</tenant_name> </openstack_volume_provider> ---- """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.OpenStackVolumeProvider), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(provider, headers, query, wait)
Adds a new volume provider. For example:
[source]
POST /ovirt-engine/api/openstackvolumeproviders
With a request body like this:
[source,xml]
#
def
list(
self,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the list of volume providers. The order of the returned list of volume providers isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of providers to return. If not specified all the providers are returned. `search`:: A query string used to restrict the returned volume providers. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the list of volume providers. The order of the returned list of volume providers isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of providers to return. If not specified all the providers are returned.
search:: A query string used to restrict the returned volume providers.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def provider_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackVolumeProviderService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.provider_service(path) return self.provider_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackVolumeTypeService(Service): """ """ def __init__(self, connection, path): super(OpenstackVolumeTypeService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OpenstackVolumeTypeService:%s' % self._path
View Source
def __init__(self, connection, path): super(OpenstackVolumeTypeService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OpenstackVolumeTypesService(Service): """ """ def __init__(self, connection, path): super(OpenstackVolumeTypesService, self).__init__(connection, path) self._type_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of volume types. The order of the returned list of volume types isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of volume types to return. If not specified all the volume types are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def type_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackVolumeTypeService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.type_service(path) return self.type_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OpenstackVolumeTypesService:%s' % self._path
View Source
def __init__(self, connection, path): super(OpenstackVolumeTypesService, self).__init__(connection, path) self._type_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of volume types. The order of the returned list of volume types isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of volume types to return. If not specified all the volume types are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of volume types. The order of the returned list of volume types isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of volume types to return. If not specified all the volume types are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def type_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OpenstackVolumeTypeService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.type_service(path) return self.type_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OperatingSystemService(Service): """ """ def __init__(self, connection, path): super(OperatingSystemService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'OperatingSystemService:%s' % self._path
View Source
def __init__(self, connection, path): super(OperatingSystemService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class OperatingSystemsService(Service): """ Manages the set of types of operating systems available in the system. """ def __init__(self, connection, path): super(OperatingSystemsService, self).__init__(connection, path) self._operating_system_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of types of operating system available in the system. The order of the returned list of operating systems isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def operating_system_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OperatingSystemService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.operating_system_service(path) return self.operating_system_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'OperatingSystemsService:%s' % self._path
Manages the set of types of operating systems available in the system.
View Source
def __init__(self, connection, path): super(OperatingSystemsService, self).__init__(connection, path) self._operating_system_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of types of operating system available in the system. The order of the returned list of operating systems isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of types of operating system available in the system. The order of the returned list of operating systems isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of networks to return. If not specified all the networks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def operating_system_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return OperatingSystemService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.operating_system_service(path) return self.operating_system_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class PermissionService(Service): """ """ def __init__(self, connection, path): super(PermissionService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'PermissionService:%s' % self._path
View Source
def __init__(self, connection, path): super(PermissionService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class PermitService(Service): """ A service to manage a specific permit of the role. """ def __init__(self, connection, path): super(PermitService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the information about the permit of the role. For example to retrieve the information about the permit with the id `456` of the role with the id `123` send a request like this: .... GET /ovirt-engine/api/roles/123/permits/456 .... [source,xml] ---- <permit href="/ovirt-engine/api/roles/123/permits/456" id="456"> <name>change_vm_cd</name> <administrative>false</administrative> <role href="/ovirt-engine/api/roles/123" id="123"/> </permit> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the permit from the role. For example to remove the permit with id `456` from the role with id `123` send a request like this: .... DELETE /ovirt-engine/api/roles/123/permits/456 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'PermitService:%s' % self._path
A service to manage a specific permit of the role.
View Source
def __init__(self, connection, path): super(PermitService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the information about the permit of the role. For example to retrieve the information about the permit with the id `456` of the role with the id `123` send a request like this: .... GET /ovirt-engine/api/roles/123/permits/456 .... [source,xml] ---- <permit href="/ovirt-engine/api/roles/123/permits/456" id="456"> <name>change_vm_cd</name> <administrative>false</administrative> <role href="/ovirt-engine/api/roles/123" id="123"/> </permit> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets the information about the permit of the role.
For example to retrieve the information about the permit with the id 456 of the role with the id 123
send a request like this:
....
GET /ovirt-engine/api/roles/123/permits/456
....
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the permit from the role. For example to remove the permit with id `456` from the role with id `123` send a request like this: .... DELETE /ovirt-engine/api/roles/123/permits/456 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the permit from the role.
For example to remove the permit with id 456 from the role with id 123 send a request like this:
....
DELETE /ovirt-engine/api/roles/123/permits/456
....
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class PermitsService(Service): """ Represents a permits sub-collection of the specific role. """ def __init__(self, connection, path): super(PermitsService, self).__init__(connection, path) self._permit_service = None def add( self, permit, headers=None, query=None, wait=True, **kwargs ): """ Adds a permit to the role. The permit name can be retrieved from the <<services/cluster_levels>> service. For example to assign a permit `create_vm` to the role with id `123` send a request like this: .... POST /ovirt-engine/api/roles/123/permits .... With a request body like this: [source,xml] ---- <permit> <name>create_vm</name> </permit> ---- This method supports the following parameters: `permit`:: The permit to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permit', permit, types.Permit), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permit, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the permits of the role. For example to list the permits of the role with the id `123` send a request like this: .... GET /ovirt-engine/api/roles/123/permits .... [source,xml] ---- <permits> <permit href="/ovirt-engine/api/roles/123/permits/5" id="5"> <name>change_vm_cd</name> <administrative>false</administrative> <role href="/ovirt-engine/api/roles/123" id="123"/> </permit> <permit href="/ovirt-engine/api/roles/123/permits/7" id="7"> <name>connect_to_vm</name> <administrative>false</administrative> <role href="/ovirt-engine/api/roles/123" id="123"/> </permit> </permits> ---- The order of the returned list of permits isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of permits to return. If not specified all the permits are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def permit_service(self, id): """ Sub-resource locator method, returns individual permit resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return PermitService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.permit_service(path) return self.permit_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'PermitsService:%s' % self._path
Represents a permits sub-collection of the specific role.
View Source
def __init__(self, connection, path): super(PermitsService, self).__init__(connection, path) self._permit_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, permit, headers=None, query=None, wait=True, **kwargs ): """ Adds a permit to the role. The permit name can be retrieved from the <<services/cluster_levels>> service. For example to assign a permit `create_vm` to the role with id `123` send a request like this: .... POST /ovirt-engine/api/roles/123/permits .... With a request body like this: [source,xml] ---- <permit> <name>create_vm</name> </permit> ---- This method supports the following parameters: `permit`:: The permit to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permit', permit, types.Permit), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permit, headers, query, wait)
Adds a permit to the role. The permit name can be retrieved from the <create_vm to the role with id 123 send a request like this:
....
POST /ovirt-engine/api/roles/123/permits
....
With a request body like this:
[source,xml]
This method supports the following parameters:
permit:: The permit to add.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the permits of the role. For example to list the permits of the role with the id `123` send a request like this: .... GET /ovirt-engine/api/roles/123/permits .... [source,xml] ---- <permits> <permit href="/ovirt-engine/api/roles/123/permits/5" id="5"> <name>change_vm_cd</name> <administrative>false</administrative> <role href="/ovirt-engine/api/roles/123" id="123"/> </permit> <permit href="/ovirt-engine/api/roles/123/permits/7" id="7"> <name>connect_to_vm</name> <administrative>false</administrative> <role href="/ovirt-engine/api/roles/123" id="123"/> </permit> </permits> ---- The order of the returned list of permits isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of permits to return. If not specified all the permits are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List the permits of the role.
For example to list the permits of the role with the id 123 send a request like this:
....
GET /ovirt-engine/api/roles/123/permits
....
[source,xml]
The order of the returned list of permits isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of permits to return. If not specified all the permits are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def permit_service(self, id): """ Sub-resource locator method, returns individual permit resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return PermitService(self._connection, '%s/%s' % (self._path, id))
Sub-resource locator method, returns individual permit resource on which the remainder of the URI is dispatched.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.permit_service(path) return self.permit_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class QosService(Service): """ """ def __init__(self, connection, path): super(QosService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get specified QoS in the data center. [source] ---- GET /ovirt-engine/api/datacenters/123/qoss/123 ---- You will get response like this one below: [source,xml] ---- <qos href="/ovirt-engine/api/datacenters/123/qoss/123" id="123"> <name>123</name> <description>123</description> <max_iops>1</max_iops> <max_throughput>1</max_throughput> <type>storage</type> <data_center href="/ovirt-engine/api/datacenters/123" id="123"/> </qos> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove specified QoS from datacenter. [source] ---- DELETE /ovirt-engine/api/datacenters/123/qoss/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, qos, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified QoS in the dataCenter. [source] ---- PUT /ovirt-engine/api/datacenters/123/qoss/123 ---- For example with curl: [source] ---- curl -u admin@internal:123456 -X PUT -H "content-type: application/xml" -d \ "<qos><name>321</name><description>321</description><max_iops>10</max_iops></qos>" \ https://engine/ovirt-engine/api/datacenters/123/qoss/123 ---- You will receive response like this: [source,xml] ---- <qos href="/ovirt-engine/api/datacenters/123/qoss/123" id="123"> <name>321</name> <description>321</description> <max_iops>10</max_iops> <max_throughput>1</max_throughput> <type>storage</type> <data_center href="/ovirt-engine/api/datacenters/123" id="123"/> </qos> ---- This method supports the following parameters: `qos`:: Updated QoS object. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('qos', qos, types.Qos), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(qos, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'QosService:%s' % self._path
View Source
def __init__(self, connection, path): super(QosService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get specified QoS in the data center. [source] ---- GET /ovirt-engine/api/datacenters/123/qoss/123 ---- You will get response like this one below: [source,xml] ---- <qos href="/ovirt-engine/api/datacenters/123/qoss/123" id="123"> <name>123</name> <description>123</description> <max_iops>1</max_iops> <max_throughput>1</max_throughput> <type>storage</type> <data_center href="/ovirt-engine/api/datacenters/123" id="123"/> </qos> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get specified QoS in the data center.
[source]
GET /ovirt-engine/api/datacenters/123/qoss/123
You will get response like this one below:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove specified QoS from datacenter. [source] ---- DELETE /ovirt-engine/api/datacenters/123/qoss/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove specified QoS from datacenter.
[source]
DELETE /ovirt-engine/api/datacenters/123/qoss/123
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, qos, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified QoS in the dataCenter. [source] ---- PUT /ovirt-engine/api/datacenters/123/qoss/123 ---- For example with curl: [source] ---- curl -u admin@internal:123456 -X PUT -H "content-type: application/xml" -d \ "<qos><name>321</name><description>321</description><max_iops>10</max_iops></qos>" \ https://engine/ovirt-engine/api/datacenters/123/qoss/123 ---- You will receive response like this: [source,xml] ---- <qos href="/ovirt-engine/api/datacenters/123/qoss/123" id="123"> <name>321</name> <description>321</description> <max_iops>10</max_iops> <max_throughput>1</max_throughput> <type>storage</type> <data_center href="/ovirt-engine/api/datacenters/123" id="123"/> </qos> ---- This method supports the following parameters: `qos`:: Updated QoS object. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('qos', qos, types.Qos), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(qos, headers, query, wait)
Update the specified QoS in the dataCenter.
[source]
PUT /ovirt-engine/api/datacenters/123/qoss/123
For example with curl:
[source]
curl -u admin@internal:123456 -X PUT -H "content-type: application/xml" -d "321 321 10
You will receive response like this:
[source,xml]
This method supports the following parameters:
qos:: Updated QoS object.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class QossService(Service): """ Manages the set of _quality of service_ configurations available in a data center. """ def __init__(self, connection, path): super(QossService, self).__init__(connection, path) self._qos_service = None def add( self, qos, headers=None, query=None, wait=True, **kwargs ): """ Add a new QoS to the dataCenter. [source] ---- POST /ovirt-engine/api/datacenters/123/qoss ---- The response will look as follows: [source,xml] ---- <qos href="/ovirt-engine/api/datacenters/123/qoss/123" id="123"> <name>123</name> <description>123</description> <max_iops>10</max_iops> <type>storage</type> <data_center href="/ovirt-engine/api/datacenters/123" id="123"/> </qos> ---- This method supports the following parameters: `qos`:: Added QoS object. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('qos', qos, types.Qos), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(qos, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of _quality of service_ configurations available in the data center. [source] ---- GET /ovirt-engine/api/datacenter/123/qoss ---- You will get response which will look like this: [source, xml] ---- <qoss> <qos href="/ovirt-engine/api/datacenters/123/qoss/1" id="1">...</qos> <qos href="/ovirt-engine/api/datacenters/123/qoss/2" id="2">...</qos> <qos href="/ovirt-engine/api/datacenters/123/qoss/3" id="3">...</qos> </qoss> ---- The returned list of quality of service configurations isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of QoS descriptors to return. If not specified all the descriptors are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def qos_service(self, id): """ A reference to a service managing a specific QoS. """ Service._check_types([ ('id', id, str), ]) return QosService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.qos_service(path) return self.qos_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'QossService:%s' % self._path
Manages the set of _quality of service_ configurations available in a data center.
View Source
def __init__(self, connection, path): super(QossService, self).__init__(connection, path) self._qos_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, qos, headers=None, query=None, wait=True, **kwargs ): """ Add a new QoS to the dataCenter. [source] ---- POST /ovirt-engine/api/datacenters/123/qoss ---- The response will look as follows: [source,xml] ---- <qos href="/ovirt-engine/api/datacenters/123/qoss/123" id="123"> <name>123</name> <description>123</description> <max_iops>10</max_iops> <type>storage</type> <data_center href="/ovirt-engine/api/datacenters/123" id="123"/> </qos> ---- This method supports the following parameters: `qos`:: Added QoS object. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('qos', qos, types.Qos), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(qos, headers, query, wait)
Add a new QoS to the dataCenter.
[source]
POST /ovirt-engine/api/datacenters/123/qoss
The response will look as follows:
[source,xml]
This method supports the following parameters:
qos:: Added QoS object.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of _quality of service_ configurations available in the data center. [source] ---- GET /ovirt-engine/api/datacenter/123/qoss ---- You will get response which will look like this: [source, xml] ---- <qoss> <qos href="/ovirt-engine/api/datacenters/123/qoss/1" id="1">...</qos> <qos href="/ovirt-engine/api/datacenters/123/qoss/2" id="2">...</qos> <qos href="/ovirt-engine/api/datacenters/123/qoss/3" id="3">...</qos> </qoss> ---- The returned list of quality of service configurations isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of QoS descriptors to return. If not specified all the descriptors are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of _quality of service_ configurations available in the data center.
[source]
GET /ovirt-engine/api/datacenter/123/qoss
You will get response which will look like this:
[source, xml]
The returned list of quality of service configurations isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of QoS descriptors to return. If not specified all the descriptors are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def qos_service(self, id): """ A reference to a service managing a specific QoS. """ Service._check_types([ ('id', id, str), ]) return QosService(self._connection, '%s/%s' % (self._path, id))
A reference to a service managing a specific QoS.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.qos_service(path) return self.qos_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class QuotaService(Service): """ """ def __init__(self, connection, path): super(QuotaService, self).__init__(connection, path) self._permissions_service = None self._quota_cluster_limits_service = None self._quota_storage_limits_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a quota. An example of retrieving a quota: [source] ---- GET /ovirt-engine/api/datacenters/123/quotas/456 ---- [source,xml] ---- <quota id="456"> <name>myquota</name> <description>My new quota for virtual machines</description> <cluster_hard_limit_pct>20</cluster_hard_limit_pct> <cluster_soft_limit_pct>80</cluster_soft_limit_pct> <storage_hard_limit_pct>20</storage_hard_limit_pct> <storage_soft_limit_pct>80</storage_soft_limit_pct> </quota> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Delete a quota. An example of deleting a quota: [source] ---- DELETE /ovirt-engine/api/datacenters/123-456/quotas/654-321 -0472718ab224 HTTP/1.1 Accept: application/xml Content-type: application/xml ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, quota, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a quota. An example of updating a quota: [source] ---- PUT /ovirt-engine/api/datacenters/123/quotas/456 ---- [source,xml] ---- <quota> <cluster_hard_limit_pct>30</cluster_hard_limit_pct> <cluster_soft_limit_pct>70</cluster_soft_limit_pct> <storage_hard_limit_pct>20</storage_hard_limit_pct> <storage_soft_limit_pct>80</storage_soft_limit_pct> </quota> ---- """ # Check the types of the parameters: Service._check_types([ ('quota', quota, types.Quota), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(quota, headers, query, wait) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def quota_cluster_limits_service(self): """ """ return QuotaClusterLimitsService(self._connection, '%s/quotaclusterlimits' % self._path) def quota_storage_limits_service(self): """ """ return QuotaStorageLimitsService(self._connection, '%s/quotastoragelimits' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'quotaclusterlimits': return self.quota_cluster_limits_service() if path.startswith('quotaclusterlimits/'): return self.quota_cluster_limits_service().service(path[19:]) if path == 'quotastoragelimits': return self.quota_storage_limits_service() if path.startswith('quotastoragelimits/'): return self.quota_storage_limits_service().service(path[19:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'QuotaService:%s' % self._path
View Source
def __init__(self, connection, path): super(QuotaService, self).__init__(connection, path) self._permissions_service = None self._quota_cluster_limits_service = None self._quota_storage_limits_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a quota. An example of retrieving a quota: [source] ---- GET /ovirt-engine/api/datacenters/123/quotas/456 ---- [source,xml] ---- <quota id="456"> <name>myquota</name> <description>My new quota for virtual machines</description> <cluster_hard_limit_pct>20</cluster_hard_limit_pct> <cluster_soft_limit_pct>80</cluster_soft_limit_pct> <storage_hard_limit_pct>20</storage_hard_limit_pct> <storage_soft_limit_pct>80</storage_soft_limit_pct> </quota> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves a quota. An example of retrieving a quota:
[source]
GET /ovirt-engine/api/datacenters/123/quotas/456
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Delete a quota. An example of deleting a quota: [source] ---- DELETE /ovirt-engine/api/datacenters/123-456/quotas/654-321 -0472718ab224 HTTP/1.1 Accept: application/xml Content-type: application/xml ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Delete a quota. An example of deleting a quota:
[source]
DELETE /ovirt-engine/api/datacenters/123-456/quotas/654-321 -0472718ab224 HTTP/1.1 Accept: application/xml
Content-type: application/xml
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, quota, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a quota. An example of updating a quota: [source] ---- PUT /ovirt-engine/api/datacenters/123/quotas/456 ---- [source,xml] ---- <quota> <cluster_hard_limit_pct>30</cluster_hard_limit_pct> <cluster_soft_limit_pct>70</cluster_soft_limit_pct> <storage_hard_limit_pct>20</storage_hard_limit_pct> <storage_soft_limit_pct>80</storage_soft_limit_pct> </quota> ---- """ # Check the types of the parameters: Service._check_types([ ('quota', quota, types.Quota), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(quota, headers, query, wait)
Updates a quota. An example of updating a quota:
[source]
PUT /ovirt-engine/api/datacenters/123/quotas/456
[source,xml]
View Source
def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
View Source
def quota_cluster_limits_service(self): """ """ return QuotaClusterLimitsService(self._connection, '%s/quotaclusterlimits' % self._path)
View Source
def quota_storage_limits_service(self): """ """ return QuotaStorageLimitsService(self._connection, '%s/quotastoragelimits' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'quotaclusterlimits': return self.quota_cluster_limits_service() if path.startswith('quotaclusterlimits/'): return self.quota_cluster_limits_service().service(path[19:]) if path == 'quotastoragelimits': return self.quota_storage_limits_service() if path.startswith('quotastoragelimits/'): return self.quota_storage_limits_service().service(path[19:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class QuotaClusterLimitService(Service): """ """ def __init__(self, connection, path): super(QuotaClusterLimitService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'QuotaClusterLimitService:%s' % self._path
View Source
def __init__(self, connection, path): super(QuotaClusterLimitService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class QuotaClusterLimitsService(Service): """ Manages the set of quota limits configured for a cluster. """ def __init__(self, connection, path): super(QuotaClusterLimitsService, self).__init__(connection, path) self._limit_service = None def add( self, limit, headers=None, query=None, wait=True, **kwargs ): """ Add a cluster limit to a specified Quota. """ # Check the types of the parameters: Service._check_types([ ('limit', limit, types.QuotaClusterLimit), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(limit, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the set of quota limits configured for the cluster. The returned list of quota limits isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of limits to return. If not specified all the limits are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def limit_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return QuotaClusterLimitService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.limit_service(path) return self.limit_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'QuotaClusterLimitsService:%s' % self._path
Manages the set of quota limits configured for a cluster.
View Source
def __init__(self, connection, path): super(QuotaClusterLimitsService, self).__init__(connection, path) self._limit_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, limit, headers=None, query=None, wait=True, **kwargs ): """ Add a cluster limit to a specified Quota. """ # Check the types of the parameters: Service._check_types([ ('limit', limit, types.QuotaClusterLimit), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(limit, headers, query, wait)
Add a cluster limit to a specified Quota.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the set of quota limits configured for the cluster. The returned list of quota limits isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of limits to return. If not specified all the limits are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the set of quota limits configured for the cluster. The returned list of quota limits isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of limits to return. If not specified all the limits are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def limit_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return QuotaClusterLimitService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.limit_service(path) return self.limit_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class QuotaStorageLimitService(Service): """ """ def __init__(self, connection, path): super(QuotaStorageLimitService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the update should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'QuotaStorageLimitService:%s' % self._path
View Source
def __init__(self, connection, path): super(QuotaStorageLimitService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the update should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the update should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class QuotaStorageLimitsService(Service): """ Manages the set of storage limits configured for a quota. """ def __init__(self, connection, path): super(QuotaStorageLimitsService, self).__init__(connection, path) self._limit_service = None def add( self, limit, headers=None, query=None, wait=True, **kwargs ): """ Adds a storage limit to a specified quota. To create a 100GiB storage limit for all storage domains in a data center, send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/quotas/456/quotastoragelimits ---- With a request body like this: [source,xml] ---- <quota_storage_limit> <limit>100</limit> </quota_storage_limit> ---- To create a 50GiB storage limit for a storage domain with the ID `000`, send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/quotas/456/quotastoragelimits ---- With a request body like this: [source,xml] ---- <quota_storage_limit> <limit>50</limit> <storage_domain id="000"/> </quota_storage_limit> ---- """ # Check the types of the parameters: Service._check_types([ ('limit', limit, types.QuotaStorageLimit), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(limit, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of storage limits configured for the quota. The order of the returned list of storage limits is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of limits to return. If not specified, all the limits are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def limit_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return QuotaStorageLimitService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.limit_service(path) return self.limit_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'QuotaStorageLimitsService:%s' % self._path
Manages the set of storage limits configured for a quota.
View Source
def __init__(self, connection, path): super(QuotaStorageLimitsService, self).__init__(connection, path) self._limit_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, limit, headers=None, query=None, wait=True, **kwargs ): """ Adds a storage limit to a specified quota. To create a 100GiB storage limit for all storage domains in a data center, send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/quotas/456/quotastoragelimits ---- With a request body like this: [source,xml] ---- <quota_storage_limit> <limit>100</limit> </quota_storage_limit> ---- To create a 50GiB storage limit for a storage domain with the ID `000`, send a request like this: [source] ---- POST /ovirt-engine/api/datacenters/123/quotas/456/quotastoragelimits ---- With a request body like this: [source,xml] ---- <quota_storage_limit> <limit>50</limit> <storage_domain id="000"/> </quota_storage_limit> ---- """ # Check the types of the parameters: Service._check_types([ ('limit', limit, types.QuotaStorageLimit), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(limit, headers, query, wait)
Adds a storage limit to a specified quota. To create a 100GiB storage limit for all storage domains in a data center, send a request like this:
[source]
POST /ovirt-engine/api/datacenters/123/quotas/456/quotastoragelimits
With a request body like this:
[source,xml]
To create a 50GiB storage limit for a storage domain with the ID 000, send a request like this:
[source]
POST /ovirt-engine/api/datacenters/123/quotas/456/quotastoragelimits
With a request body like this:
[source,xml]
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of storage limits configured for the quota. The order of the returned list of storage limits is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of limits to return. If not specified, all the limits are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of storage limits configured for the quota. The order of the returned list of storage limits is not guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of limits to return. If not specified, all the limits are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def limit_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return QuotaStorageLimitService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.limit_service(path) return self.limit_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class QuotasService(Service): """ Manages the set of quotas configured for a data center. """ def __init__(self, connection, path): super(QuotasService, self).__init__(connection, path) self._quota_service = None def add( self, quota, headers=None, query=None, wait=True, **kwargs ): """ Creates a new quota. An example of creating a new quota: [source] ---- POST /ovirt-engine/api/datacenters/123/quotas ---- [source,xml] ---- <quota> <name>myquota</name> <description>My new quota for virtual machines</description> </quota> ---- """ # Check the types of the parameters: Service._check_types([ ('quota', quota, types.Quota), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(quota, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists quotas of a data center. The order of the returned list of quotas isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of quota descriptors to return. If not specified all the descriptors are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def quota_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return QuotaService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.quota_service(path) return self.quota_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'QuotasService:%s' % self._path
Manages the set of quotas configured for a data center.
View Source
def __init__(self, connection, path): super(QuotasService, self).__init__(connection, path) self._quota_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, quota, headers=None, query=None, wait=True, **kwargs ): """ Creates a new quota. An example of creating a new quota: [source] ---- POST /ovirt-engine/api/datacenters/123/quotas ---- [source,xml] ---- <quota> <name>myquota</name> <description>My new quota for virtual machines</description> </quota> ---- """ # Check the types of the parameters: Service._check_types([ ('quota', quota, types.Quota), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(quota, headers, query, wait)
Creates a new quota. An example of creating a new quota:
[source]
POST /ovirt-engine/api/datacenters/123/quotas
[source,xml]
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists quotas of a data center. The order of the returned list of quotas isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of quota descriptors to return. If not specified all the descriptors are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists quotas of a data center. The order of the returned list of quotas isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of quota descriptors to return. If not specified all the descriptors are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def quota_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return QuotaService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.quota_service(path) return self.quota_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class RoleService(Service): """ """ def __init__(self, connection, path): super(RoleService, self).__init__(connection, path) self._permits_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get the role. [source] ---- GET /ovirt-engine/api/roles/123 ---- You will receive XML response like this one: [source,xml] ---- <role id="123"> <name>MyRole</name> <description>MyRole description</description> <link href="/ovirt-engine/api/roles/123/permits" rel="permits"/> <administrative>true</administrative> <mutable>false</mutable> </role> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the role. To remove the role you need to know its id, then send request like this: [source] ---- DELETE /ovirt-engine/api/roles/{role_id} ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, role, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a role. You are allowed to update `name`, `description` and `administrative` attributes after role is created. Within this endpoint you can't add or remove roles permits you need to use <<services/permits, service>> that manages permits of role. For example to update role's `name`, `description` and `administrative` attributes send a request like this: [source] ---- PUT /ovirt-engine/api/roles/123 ---- With a request body like this: [source,xml] ---- <role> <name>MyNewRoleName</name> <description>My new description of the role</description> <administrative>true</administrative> </group> ---- This method supports the following parameters: `role`:: Updated role. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('role', role, types.Role), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(role, headers, query, wait) def permits_service(self): """ Sub-resource locator method, returns permits service. """ return PermitsService(self._connection, '%s/permits' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permits': return self.permits_service() if path.startswith('permits/'): return self.permits_service().service(path[8:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'RoleService:%s' % self._path
View Source
def __init__(self, connection, path): super(RoleService, self).__init__(connection, path) self._permits_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get the role. [source] ---- GET /ovirt-engine/api/roles/123 ---- You will receive XML response like this one: [source,xml] ---- <role id="123"> <name>MyRole</name> <description>MyRole description</description> <link href="/ovirt-engine/api/roles/123/permits" rel="permits"/> <administrative>true</administrative> <mutable>false</mutable> </role> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get the role.
[source]
GET /ovirt-engine/api/roles/123
You will receive XML response like this one:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the role. To remove the role you need to know its id, then send request like this: [source] ---- DELETE /ovirt-engine/api/roles/{role_id} ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the role. To remove the role you need to know its id, then send request like this:
[source]
DELETE /ovirt-engine/api/roles/{role_id}
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, role, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a role. You are allowed to update `name`, `description` and `administrative` attributes after role is created. Within this endpoint you can't add or remove roles permits you need to use <<services/permits, service>> that manages permits of role. For example to update role's `name`, `description` and `administrative` attributes send a request like this: [source] ---- PUT /ovirt-engine/api/roles/123 ---- With a request body like this: [source,xml] ---- <role> <name>MyNewRoleName</name> <description>My new description of the role</description> <administrative>true</administrative> </group> ---- This method supports the following parameters: `role`:: Updated role. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('role', role, types.Role), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(role, headers, query, wait)
Updates a role. You are allowed to update name, description and administrative attributes after role is
created. Within this endpoint you can't add or remove roles permits you need to use
<name, description and administrative attributes send a request like this:
[source]
PUT /ovirt-engine/api/roles/123
With a request body like this:
[source,xml]
This method supports the following parameters:
role:: Updated role.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def permits_service(self): """ Sub-resource locator method, returns permits service. """ return PermitsService(self._connection, '%s/permits' % self._path)
Sub-resource locator method, returns permits service.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permits': return self.permits_service() if path.startswith('permits/'): return self.permits_service().service(path[8:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class RolesService(Service): """ Provides read-only access to the global set of roles """ def __init__(self, connection, path): super(RolesService, self).__init__(connection, path) self._role_service = None def add( self, role, headers=None, query=None, wait=True, **kwargs ): """ Create a new role. The role can be administrative or non-administrative and can have different permits. For example, to add the `MyRole` non-administrative role with permits to login and create virtual machines send a request like this (note that you have to pass permit id): [source] ---- POST /ovirt-engine/api/roles ---- With a request body like this: [source,xml] ---- <role> <name>MyRole</name> <description>My custom role to create virtual machines</description> <administrative>false</administrative> <permits> <permit id="1"/> <permit id="1300"/> </permits> </group> ---- This method supports the following parameters: `role`:: Role that will be added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('role', role, types.Role), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(role, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List roles. [source] ---- GET /ovirt-engine/api/roles ---- You will receive response in XML like this one: [source,xml] ---- <roles> <role id="123"> <name>SuperUser</name> <description>Roles management administrator</description> <link href="/ovirt-engine/api/roles/123/permits" rel="permits"/> <administrative>true</administrative> <mutable>false</mutable> </role> ... </roles> ---- The order of the returned list of roles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of roles to return. If not specified all the roles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def role_service(self, id): """ Sub-resource locator method, returns individual role resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return RoleService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.role_service(path) return self.role_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'RolesService:%s' % self._path
Provides read-only access to the global set of roles
View Source
def __init__(self, connection, path): super(RolesService, self).__init__(connection, path) self._role_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, role, headers=None, query=None, wait=True, **kwargs ): """ Create a new role. The role can be administrative or non-administrative and can have different permits. For example, to add the `MyRole` non-administrative role with permits to login and create virtual machines send a request like this (note that you have to pass permit id): [source] ---- POST /ovirt-engine/api/roles ---- With a request body like this: [source,xml] ---- <role> <name>MyRole</name> <description>My custom role to create virtual machines</description> <administrative>false</administrative> <permits> <permit id="1"/> <permit id="1300"/> </permits> </group> ---- This method supports the following parameters: `role`:: Role that will be added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('role', role, types.Role), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(role, headers, query, wait)
Create a new role. The role can be administrative or non-administrative and can have different permits.
For example, to add the MyRole non-administrative role with permits to login and create virtual machines
send a request like this (note that you have to pass permit id):
[source]
POST /ovirt-engine/api/roles
With a request body like this:
[source,xml]
This method supports the following parameters:
role:: Role that will be added.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List roles. [source] ---- GET /ovirt-engine/api/roles ---- You will receive response in XML like this one: [source,xml] ---- <roles> <role id="123"> <name>SuperUser</name> <description>Roles management administrator</description> <link href="/ovirt-engine/api/roles/123/permits" rel="permits"/> <administrative>true</administrative> <mutable>false</mutable> </role> ... </roles> ---- The order of the returned list of roles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of roles to return. If not specified all the roles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List roles.
[source]
GET /ovirt-engine/api/roles
You will receive response in XML like this one:
[source,xml]
The order of the returned list of roles isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of roles to return. If not specified all the roles are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def role_service(self, id): """ Sub-resource locator method, returns individual role resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return RoleService(self._connection, '%s/%s' % (self._path, id))
Sub-resource locator method, returns individual role resource on which the remainder of the URI is dispatched.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.role_service(path) return self.role_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SchedulingPoliciesService(Service): """ Manages the set of scheduling policies available in the system. """ def __init__(self, connection, path): super(SchedulingPoliciesService, self).__init__(connection, path) self._policy_service = None def add( self, policy, headers=None, query=None, wait=True, **kwargs ): """ Add a new scheduling policy to the system. """ # Check the types of the parameters: Service._check_types([ ('policy', policy, types.SchedulingPolicy), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(policy, headers, query, wait) def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of scheduling policies available in the system. The order of the returned list of scheduling policies isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of policies to return. If not specified all the policies are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def policy_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SchedulingPolicyService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.policy_service(path) return self.policy_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SchedulingPoliciesService:%s' % self._path
Manages the set of scheduling policies available in the system.
View Source
def __init__(self, connection, path): super(SchedulingPoliciesService, self).__init__(connection, path) self._policy_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, policy, headers=None, query=None, wait=True, **kwargs ): """ Add a new scheduling policy to the system. """ # Check the types of the parameters: Service._check_types([ ('policy', policy, types.SchedulingPolicy), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(policy, headers, query, wait)
Add a new scheduling policy to the system.
#
def
list(
self,
filter=None,
follow=None,
max=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of scheduling policies available in the system. The order of the returned list of scheduling policies isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of policies to return. If not specified all the policies are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of scheduling policies available in the system. The order of the returned list of scheduling policies isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of policies to return. If not specified all the policies are returned.
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def policy_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SchedulingPolicyService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.policy_service(path) return self.policy_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SchedulingPolicyService(Service): """ """ def __init__(self, connection, path): super(SchedulingPolicyService, self).__init__(connection, path) self._balances_service = None self._filters_service = None self._weights_service = None def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, policy, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified user defined scheduling policy in the system. """ # Check the types of the parameters: Service._check_types([ ('policy', policy, types.SchedulingPolicy), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(policy, headers, query, wait) def balances_service(self): """ """ return BalancesService(self._connection, '%s/balances' % self._path) def filters_service(self): """ """ return FiltersService(self._connection, '%s/filters' % self._path) def weights_service(self): """ """ return WeightsService(self._connection, '%s/weights' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'balances': return self.balances_service() if path.startswith('balances/'): return self.balances_service().service(path[9:]) if path == 'filters': return self.filters_service() if path.startswith('filters/'): return self.filters_service().service(path[8:]) if path == 'weights': return self.weights_service() if path.startswith('weights/'): return self.weights_service().service(path[8:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SchedulingPolicyService:%s' % self._path
View Source
def __init__(self, connection, path): super(SchedulingPolicyService, self).__init__(connection, path) self._balances_service = None self._filters_service = None self._weights_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, policy, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified user defined scheduling policy in the system. """ # Check the types of the parameters: Service._check_types([ ('policy', policy, types.SchedulingPolicy), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(policy, headers, query, wait)
Update the specified user defined scheduling policy in the system.
View Source
def balances_service(self): """ """ return BalancesService(self._connection, '%s/balances' % self._path)
View Source
def filters_service(self): """ """ return FiltersService(self._connection, '%s/filters' % self._path)
View Source
def weights_service(self): """ """ return WeightsService(self._connection, '%s/weights' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'balances': return self.balances_service() if path.startswith('balances/'): return self.balances_service().service(path[9:]) if path == 'filters': return self.filters_service() if path.startswith('filters/'): return self.filters_service().service(path[8:]) if path == 'weights': return self.weights_service() if path.startswith('weights/'): return self.weights_service().service(path[8:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SchedulingPolicyUnitService(Service): """ """ def __init__(self, connection, path): super(SchedulingPolicyUnitService, self).__init__(connection, path) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SchedulingPolicyUnitService:%s' % self._path
View Source
def __init__(self, connection, path): super(SchedulingPolicyUnitService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SchedulingPolicyUnitsService(Service): """ Manages the set of scheduling policy units available in the system. """ def __init__(self, connection, path): super(SchedulingPolicyUnitsService, self).__init__(connection, path) self._unit_service = None def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of scheduling policy units available in the system. The order of the returned list of scheduling policy units isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of policy units to return. If not specified all the policy units are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def unit_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SchedulingPolicyUnitService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.unit_service(path) return self.unit_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SchedulingPolicyUnitsService:%s' % self._path
Manages the set of scheduling policy units available in the system.
View Source
def __init__(self, connection, path): super(SchedulingPolicyUnitsService, self).__init__(connection, path) self._unit_service = None
Creates a new service that will use the given connection and path.
#
def
list(
self,
filter=None,
follow=None,
max=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of scheduling policy units available in the system. The order of the returned list of scheduling policy units isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of policy units to return. If not specified all the policy units are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of scheduling policy units available in the system. The order of the returned list of scheduling policy units isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of policy units to return. If not specified all the policy units are returned.
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def unit_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SchedulingPolicyUnitService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.unit_service(path) return self.unit_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SnapshotService(Service): """ """ def __init__(self, connection, path): super(SnapshotService, self).__init__(connection, path) self._cdroms_service = None self._disks_service = None self._nics_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, all_content=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `all_content`:: Indicates if all the attributes of the virtual machine snapshot should be included in the response. By default the attribute `initialization.configuration.data` is excluded. For example, to retrieve the complete representation of the snapshot with id `456` of the virtual machine with id `123` send a request like this: .... GET /ovirt-engine/api/vms/123/snapshots/456?all_content=true .... `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('all_content', all_content, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content # Send the request and wait for the response: self._internal_remove(headers, query, wait) def restore( self, async_=None, disks=None, restore_memory=None, headers=None, query=None, wait=True, **kwargs ): """ Restores a virtual machine snapshot. For example, to restore the snapshot with identifier `456` of virtual machine with identifier `123` send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/snapshots/456/restore ---- With an empty `action` in the body: [source,xml] ---- <action/> ---- NOTE: Confirm that the commit operation is finished and the virtual machine is down before running the virtual machine. This method supports the following parameters: `disks`:: Specify the disks included in the snapshot's restore. For each disk parameter, it is also required to specify its `image_id`. For example, to restore a snapshot with an identifier `456` of a virtual machine with identifier `123`, including a disk with identifier `111` and `image_id` of `222`, send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/snapshots/456/restore ---- Request body: [source,xml] ---- <action> <disks> <disk id="111"> <image_id>222</image_id> </disk> </disks> </action> ---- `async_`:: Indicates if the restore should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('disks', disks, list), ('restore_memory', restore_memory, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, disks=disks, restore_memory=restore_memory, ) # Send the request and wait for the response: return self._internal_action(action, 'restore', None, headers, query, wait) def cdroms_service(self): """ """ return SnapshotCdromsService(self._connection, '%s/cdroms' % self._path) def disks_service(self): """ """ return SnapshotDisksService(self._connection, '%s/disks' % self._path) def nics_service(self): """ """ return SnapshotNicsService(self._connection, '%s/nics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'cdroms': return self.cdroms_service() if path.startswith('cdroms/'): return self.cdroms_service().service(path[7:]) if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SnapshotService:%s' % self._path
View Source
def __init__(self, connection, path): super(SnapshotService, self).__init__(connection, path) self._cdroms_service = None self._disks_service = None self._nics_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, all_content=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `all_content`:: Indicates if all the attributes of the virtual machine snapshot should be included in the response. By default the attribute `initialization.configuration.data` is excluded. For example, to retrieve the complete representation of the snapshot with id `456` of the virtual machine with id `123` send a request like this: .... GET /ovirt-engine/api/vms/123/snapshots/456?all_content=true .... `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('all_content', all_content, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
all_content:: Indicates if all the attributes of the virtual machine snapshot should be included in the response.
By default the attribute initialization.configuration.data is excluded.
For example, to retrieve the complete representation of the snapshot with id 456 of the virtual machine
with id 123 send a request like this:
....
GET /ovirt-engine/api/vms/123/snapshots/456?all_content=true
....
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
restore(
self,
async_=None,
disks=None,
restore_memory=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def restore( self, async_=None, disks=None, restore_memory=None, headers=None, query=None, wait=True, **kwargs ): """ Restores a virtual machine snapshot. For example, to restore the snapshot with identifier `456` of virtual machine with identifier `123` send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/snapshots/456/restore ---- With an empty `action` in the body: [source,xml] ---- <action/> ---- NOTE: Confirm that the commit operation is finished and the virtual machine is down before running the virtual machine. This method supports the following parameters: `disks`:: Specify the disks included in the snapshot's restore. For each disk parameter, it is also required to specify its `image_id`. For example, to restore a snapshot with an identifier `456` of a virtual machine with identifier `123`, including a disk with identifier `111` and `image_id` of `222`, send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/snapshots/456/restore ---- Request body: [source,xml] ---- <action> <disks> <disk id="111"> <image_id>222</image_id> </disk> </disks> </action> ---- `async_`:: Indicates if the restore should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('disks', disks, list), ('restore_memory', restore_memory, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, disks=disks, restore_memory=restore_memory, ) # Send the request and wait for the response: return self._internal_action(action, 'restore', None, headers, query, wait)
Restores a virtual machine snapshot.
For example, to restore the snapshot with identifier 456 of virtual machine with identifier 123 send a
request like this:
[source]
POST /ovirt-engine/api/vms/123/snapshots/456/restore
With an empty action in the body:
[source,xml]
NOTE: Confirm that the commit operation is finished and the virtual machine is down before running the virtual machine.
This method supports the following parameters:
disks:: Specify the disks included in the snapshot's restore.
For each disk parameter, it is also required to specify its image_id.
For example, to restore a snapshot with an identifier 456 of a virtual machine with identifier 123, including
a disk with identifier 111 and image_id of 222, send a request like this:
[source]
POST /ovirt-engine/api/vms/123/snapshots/456/restore
Request body:
[source,xml]
async_:: Indicates if the restore should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def cdroms_service(self): """ """ return SnapshotCdromsService(self._connection, '%s/cdroms' % self._path)
View Source
def disks_service(self): """ """ return SnapshotDisksService(self._connection, '%s/disks' % self._path)
View Source
def nics_service(self): """ """ return SnapshotNicsService(self._connection, '%s/nics' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'cdroms': return self.cdroms_service() if path.startswith('cdroms/'): return self.cdroms_service().service(path[7:]) if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SnapshotCdromService(Service): """ """ def __init__(self, connection, path): super(SnapshotCdromService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SnapshotCdromService:%s' % self._path
View Source
def __init__(self, connection, path): super(SnapshotCdromService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SnapshotCdromsService(Service): """ Manages the set of CD-ROM devices of a virtual machine snapshot. """ def __init__(self, connection, path): super(SnapshotCdromsService, self).__init__(connection, path) self._cdrom_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of CD-ROM devices of the snapshot. The order of the returned list of CD-ROM devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of CDROMS to return. If not specified all the CDROMS are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def cdrom_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SnapshotCdromService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.cdrom_service(path) return self.cdrom_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SnapshotCdromsService:%s' % self._path
Manages the set of CD-ROM devices of a virtual machine snapshot.
View Source
def __init__(self, connection, path): super(SnapshotCdromsService, self).__init__(connection, path) self._cdrom_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of CD-ROM devices of the snapshot. The order of the returned list of CD-ROM devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of CDROMS to return. If not specified all the CDROMS are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of CD-ROM devices of the snapshot. The order of the returned list of CD-ROM devices isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of CDROMS to return. If not specified all the CDROMS are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def cdrom_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SnapshotCdromService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.cdrom_service(path) return self.cdrom_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SnapshotDiskService(Service): """ """ def __init__(self, connection, path): super(SnapshotDiskService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SnapshotDiskService:%s' % self._path
View Source
def __init__(self, connection, path): super(SnapshotDiskService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SnapshotDisksService(Service): """ Manages the set of disks of an snapshot. """ def __init__(self, connection, path): super(SnapshotDisksService, self).__init__(connection, path) self._disk_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks of the snapshot. The order of the returned list of disks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SnapshotDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SnapshotDisksService:%s' % self._path
Manages the set of disks of an snapshot.
View Source
def __init__(self, connection, path): super(SnapshotDisksService, self).__init__(connection, path) self._disk_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks of the snapshot. The order of the returned list of disks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of disks of the snapshot. The order of the returned list of disks isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of disks to return. If not specified all the disks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disk_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SnapshotDiskService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SnapshotNicService(Service): """ """ def __init__(self, connection, path): super(SnapshotNicService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SnapshotNicService:%s' % self._path
View Source
def __init__(self, connection, path): super(SnapshotNicService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SnapshotNicsService(Service): """ Manages the set of NICs of an snapshot. """ def __init__(self, connection, path): super(SnapshotNicsService, self).__init__(connection, path) self._nic_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of NICs of the snapshot. The order of the returned list of NICs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def nic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SnapshotNicService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SnapshotNicsService:%s' % self._path
Manages the set of NICs of an snapshot.
View Source
def __init__(self, connection, path): super(SnapshotNicsService, self).__init__(connection, path) self._nic_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of NICs of the snapshot. The order of the returned list of NICs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of NICs of the snapshot. The order of the returned list of NICs isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of NICs to return. If not specified all the NICs are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def nic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SnapshotNicService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SnapshotsService(Service): """ Manages the set of snapshots of a storage domain or virtual machine. """ def __init__(self, connection, path): super(SnapshotsService, self).__init__(connection, path) self._snapshot_service = None def add( self, snapshot, headers=None, query=None, wait=True, **kwargs ): """ Creates a virtual machine snapshot. For example, to create a new snapshot for virtual machine `123` send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/snapshots ---- With a request body like this: [source,xml] ---- <snapshot> <description>My snapshot</description> </snapshot> ---- For including only a sub-set of disks in the snapshots, add `disk_attachments` element to the request body. Note that disks which are not specified in `disk_attachments` element will not be a part of the snapshot. If an empty `disk_attachments` element is passed, the snapshot will include only the virtual machine configuration. If no `disk_attachments` element is passed, then all the disks will be included in the snapshot. For each disk, `image_id` element can be specified for setting the new active image id. This is used in order to restore a chain of images from backup. I.e. when restoring a disk with snapshots, the relevant `image_id` should be specified for each snapshot (so the identifiers of the disk snapshots are identical to the backup). [source,xml] ---- <snapshot> <description>My snapshot</description> <disk_attachments> <disk_attachment> <disk id="123"> <image_id>456</image_id> </disk> </disk_attachment> </disk_attachments> </snapshot> ---- [IMPORTANT] ==== When a snapshot is created the default value for the <<types/snapshot/attributes/persist_memorystate, persist_memorystate>> attribute is `true`. That means that the content of the memory of the virtual machine will be included in the snapshot, and it also means that the virtual machine will be paused for a longer time. That can negatively affect applications that are very sensitive to timing (NTP servers, for example). In those cases make sure that you set the attribute to `false`: [source,xml] ---- <snapshot> <description>My snapshot</description> <persist_memorystate>false</persist_memorystate> </snapshot> ---- ==== """ # Check the types of the parameters: Service._check_types([ ('snapshot', snapshot, types.Snapshot), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(snapshot, headers, query, wait) def list( self, all_content=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of snapshots of the storage domain or virtual machine. The order of the returned list of snapshots isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of snapshots to return. If not specified all the snapshots are returned. `all_content`:: Indicates if all the attributes of the virtual machine snapshot should be included in the response. By default the attribute `initialization.configuration.data` is excluded. For example, to retrieve the complete representation of the virtual machine with id `123` snapshots send a request like this: .... GET /ovirt-engine/api/vms/123/snapshots?all_content=true .... `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def snapshot_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SnapshotService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.snapshot_service(path) return self.snapshot_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SnapshotsService:%s' % self._path
Manages the set of snapshots of a storage domain or virtual machine.
View Source
def __init__(self, connection, path): super(SnapshotsService, self).__init__(connection, path) self._snapshot_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, snapshot, headers=None, query=None, wait=True, **kwargs ): """ Creates a virtual machine snapshot. For example, to create a new snapshot for virtual machine `123` send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/snapshots ---- With a request body like this: [source,xml] ---- <snapshot> <description>My snapshot</description> </snapshot> ---- For including only a sub-set of disks in the snapshots, add `disk_attachments` element to the request body. Note that disks which are not specified in `disk_attachments` element will not be a part of the snapshot. If an empty `disk_attachments` element is passed, the snapshot will include only the virtual machine configuration. If no `disk_attachments` element is passed, then all the disks will be included in the snapshot. For each disk, `image_id` element can be specified for setting the new active image id. This is used in order to restore a chain of images from backup. I.e. when restoring a disk with snapshots, the relevant `image_id` should be specified for each snapshot (so the identifiers of the disk snapshots are identical to the backup). [source,xml] ---- <snapshot> <description>My snapshot</description> <disk_attachments> <disk_attachment> <disk id="123"> <image_id>456</image_id> </disk> </disk_attachment> </disk_attachments> </snapshot> ---- [IMPORTANT] ==== When a snapshot is created the default value for the <<types/snapshot/attributes/persist_memorystate, persist_memorystate>> attribute is `true`. That means that the content of the memory of the virtual machine will be included in the snapshot, and it also means that the virtual machine will be paused for a longer time. That can negatively affect applications that are very sensitive to timing (NTP servers, for example). In those cases make sure that you set the attribute to `false`: [source,xml] ---- <snapshot> <description>My snapshot</description> <persist_memorystate>false</persist_memorystate> </snapshot> ---- ==== """ # Check the types of the parameters: Service._check_types([ ('snapshot', snapshot, types.Snapshot), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(snapshot, headers, query, wait)
Creates a virtual machine snapshot.
For example, to create a new snapshot for virtual machine 123 send a request like this:
[source]
POST /ovirt-engine/api/vms/123/snapshots
With a request body like this:
[source,xml]
For including only a sub-set of disks in the snapshots, add disk_attachments element to the
request body. Note that disks which are not specified in disk_attachments element will not be a
part of the snapshot. If an empty disk_attachments element is passed, the snapshot will include
only the virtual machine configuration. If no disk_attachments element is passed, then all
the disks will be included in the snapshot.
For each disk, image_id element can be specified for setting the new active image id.
This is used in order to restore a chain of images from backup. I.e. when restoring
a disk with snapshots, the relevant image_id should be specified for each snapshot
(so the identifiers of the disk snapshots are identical to the backup).
[source,xml]
[IMPORTANT]
When a snapshot is created the default value for the <true. That means that the content of the memory of the virtual
machine will be included in the snapshot, and it also means that the virtual machine will be paused
for a longer time. That can negatively affect applications that are very sensitive to timing (NTP
servers, for example). In those cases make sure that you set the attribute to false:
[source,xml]
====
#
def
list(
self,
all_content=None,
follow=None,
max=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, all_content=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of snapshots of the storage domain or virtual machine. The order of the returned list of snapshots isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of snapshots to return. If not specified all the snapshots are returned. `all_content`:: Indicates if all the attributes of the virtual machine snapshot should be included in the response. By default the attribute `initialization.configuration.data` is excluded. For example, to retrieve the complete representation of the virtual machine with id `123` snapshots send a request like this: .... GET /ovirt-engine/api/vms/123/snapshots?all_content=true .... `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of snapshots of the storage domain or virtual machine. The order of the returned list of snapshots isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of snapshots to return. If not specified all the snapshots are returned.
all_content:: Indicates if all the attributes of the virtual machine snapshot should be included in the response.
By default the attribute initialization.configuration.data is excluded.
For example, to retrieve the complete representation of the virtual machine with id 123 snapshots send a
request like this:
....
GET /ovirt-engine/api/vms/123/snapshots?all_content=true
....
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def snapshot_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SnapshotService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.snapshot_service(path) return self.snapshot_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SshPublicKeyService(Service): """ """ def __init__(self, connection, path): super(SshPublicKeyService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, key, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Replaces the key with a new resource. IMPORTANT: Since version 4.4.8 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. Instead please use DELETE followed by <<services/ssh_public_keys/methods/add, add operation>>. """ # Check the types of the parameters: Service._check_types([ ('key', key, types.SshPublicKey), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(key, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SshPublicKeyService:%s' % self._path
View Source
def __init__(self, connection, path): super(SshPublicKeyService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, key, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Replaces the key with a new resource. IMPORTANT: Since version 4.4.8 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. Instead please use DELETE followed by <<services/ssh_public_keys/methods/add, add operation>>. """ # Check the types of the parameters: Service._check_types([ ('key', key, types.SshPublicKey), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(key, headers, query, wait)
Replaces the key with a new resource.
IMPORTANT: Since version 4.4.8 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. Instead please use DELETE followed by <
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SshPublicKeysService(Service): """ """ def __init__(self, connection, path): super(SshPublicKeysService, self).__init__(connection, path) self._key_service = None def add( self, key, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('key', key, types.SshPublicKey), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(key, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns a list of SSH public keys of the user. For example, to retrieve the list of SSH keys of user with identifier `123`, send a request like this: [source] ---- GET /ovirt-engine/api/users/123/sshpublickeys ---- The result will be the following XML document: [source,xml] ---- <ssh_public_keys> <ssh_public_key href="/ovirt-engine/api/users/123/sshpublickeys/456" id="456"> <content>ssh-rsa ...</content> <user href="/ovirt-engine/api/users/123" id="123"/> </ssh_public_key> </ssh_public_keys> ---- Or the following JSON object [source,json] ---- { "ssh_public_key": [ { "content": "ssh-rsa ...", "user": { "href": "/ovirt-engine/api/users/123", "id": "123" }, "href": "/ovirt-engine/api/users/123/sshpublickeys/456", "id": "456" } ] } ---- The order of the returned list of keys is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of keys to return. If not specified all the keys are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def key_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SshPublicKeyService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.key_service(path) return self.key_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SshPublicKeysService:%s' % self._path
View Source
def __init__(self, connection, path): super(SshPublicKeysService, self).__init__(connection, path) self._key_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, key, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('key', key, types.SshPublicKey), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(key, headers, query, wait)
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns a list of SSH public keys of the user. For example, to retrieve the list of SSH keys of user with identifier `123`, send a request like this: [source] ---- GET /ovirt-engine/api/users/123/sshpublickeys ---- The result will be the following XML document: [source,xml] ---- <ssh_public_keys> <ssh_public_key href="/ovirt-engine/api/users/123/sshpublickeys/456" id="456"> <content>ssh-rsa ...</content> <user href="/ovirt-engine/api/users/123" id="123"/> </ssh_public_key> </ssh_public_keys> ---- Or the following JSON object [source,json] ---- { "ssh_public_key": [ { "content": "ssh-rsa ...", "user": { "href": "/ovirt-engine/api/users/123", "id": "123" }, "href": "/ovirt-engine/api/users/123/sshpublickeys/456", "id": "456" } ] } ---- The order of the returned list of keys is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of keys to return. If not specified all the keys are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns a list of SSH public keys of the user.
For example, to retrieve the list of SSH keys of user with identifier 123,
send a request like this:
[source]
GET /ovirt-engine/api/users/123/sshpublickeys
The result will be the following XML document:
[source,xml]
Or the following JSON object
[source,json]
{ "ssh_public_key": [ { "content": "ssh-rsa ...", "user": { "href": "/ovirt-engine/api/users/123", "id": "123" }, "href": "/ovirt-engine/api/users/123/sshpublickeys/456", "id": "456" } ]
}
The order of the returned list of keys is not guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of keys to return. If not specified all the keys are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def key_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return SshPublicKeyService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.key_service(path) return self.key_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StatisticService(Service): """ """ def __init__(self, connection, path): super(StatisticService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StatisticService:%s' % self._path
View Source
def __init__(self, connection, path): super(StatisticService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StatisticsService(Service): """ """ def __init__(self, connection, path): super(StatisticsService, self).__init__(connection, path) self._statistic_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a list of statistics. For example, to retrieve the statistics for virtual machine `123` send a request like this: [source] ---- GET /ovirt-engine/api/vms/123/statistics ---- The result will be like this: [source,xml] ---- <statistics> <statistic href="/ovirt-engine/api/vms/123/statistics/456" id="456"> <name>memory.installed</name> <description>Total memory configured</description> <kind>gauge</kind> <type>integer</type> <unit>bytes</unit> <values> <value> <datum>1073741824</datum> </value> </values> <vm href="/ovirt-engine/api/vms/123" id="123"/> </statistic> ... </statistics> ---- Just a single part of the statistics can be retrieved by specifying its id at the end of the URI. That means: [source] ---- GET /ovirt-engine/api/vms/123/statistics/456 ---- Outputs: [source,xml] ---- <statistic href="/ovirt-engine/api/vms/123/statistics/456" id="456"> <name>memory.installed</name> <description>Total memory configured</description> <kind>gauge</kind> <type>integer</type> <unit>bytes</unit> <values> <value> <datum>1073741824</datum> </value> </values> <vm href="/ovirt-engine/api/vms/123" id="123"/> </statistic> ---- The order of the returned list of statistics isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of statistics to return. If not specified all the statistics are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def statistic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StatisticService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.statistic_service(path) return self.statistic_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StatisticsService:%s' % self._path
View Source
def __init__(self, connection, path): super(StatisticsService, self).__init__(connection, path) self._statistic_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a list of statistics. For example, to retrieve the statistics for virtual machine `123` send a request like this: [source] ---- GET /ovirt-engine/api/vms/123/statistics ---- The result will be like this: [source,xml] ---- <statistics> <statistic href="/ovirt-engine/api/vms/123/statistics/456" id="456"> <name>memory.installed</name> <description>Total memory configured</description> <kind>gauge</kind> <type>integer</type> <unit>bytes</unit> <values> <value> <datum>1073741824</datum> </value> </values> <vm href="/ovirt-engine/api/vms/123" id="123"/> </statistic> ... </statistics> ---- Just a single part of the statistics can be retrieved by specifying its id at the end of the URI. That means: [source] ---- GET /ovirt-engine/api/vms/123/statistics/456 ---- Outputs: [source,xml] ---- <statistic href="/ovirt-engine/api/vms/123/statistics/456" id="456"> <name>memory.installed</name> <description>Total memory configured</description> <kind>gauge</kind> <type>integer</type> <unit>bytes</unit> <values> <value> <datum>1073741824</datum> </value> </values> <vm href="/ovirt-engine/api/vms/123" id="123"/> </statistic> ---- The order of the returned list of statistics isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of statistics to return. If not specified all the statistics are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves a list of statistics.
For example, to retrieve the statistics for virtual machine 123 send a
request like this:
[source]
GET /ovirt-engine/api/vms/123/statistics
The result will be like this:
[source,xml]
Just a single part of the statistics can be retrieved by specifying its id at the end of the URI. That means:
[source]
GET /ovirt-engine/api/vms/123/statistics/456
Outputs:
[source,xml]
The order of the returned list of statistics isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of statistics to return. If not specified all the statistics are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def statistic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StatisticService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.statistic_service(path) return self.statistic_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StepService(MeasurableService): """ A service to manage a step. """ def __init__(self, connection, path): super(StepService, self).__init__(connection, path) self._statistics_service = None def end( self, async_=None, force=None, succeeded=None, headers=None, query=None, wait=True, **kwargs ): """ Marks an external step execution as ended. For example, to terminate a step with identifier `456` which belongs to a `job` with identifier `123` send the following request: [source] ---- POST /ovirt-engine/api/jobs/123/steps/456/end ---- With the following request body: [source,xml] ---- <action> <force>true</force> <succeeded>true</succeeded> </action> ---- This method supports the following parameters: `force`:: Indicates if the step should be forcibly terminated. `succeeded`:: Indicates if the step should be marked as successfully finished or as failed. This parameter is optional, and the default value is `true`. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('succeeded', succeeded, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, succeeded=succeeded, ) # Send the request and wait for the response: return self._internal_action(action, 'end', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a step. [source] ---- GET /ovirt-engine/api/jobs/123/steps/456 ---- You will receive response in XML like this one: [source,xml] ---- <step href="/ovirt-engine/api/jobs/123/steps/456" id="456"> <actions> <link href="/ovirt-engine/api/jobs/123/steps/456/end" rel="end"/> </actions> <description>Validating</description> <end_time>2016-12-12T23:07:26.627+02:00</end_time> <external>false</external> <number>0</number> <start_time>2016-12-12T23:07:26.605+02:00</start_time> <status>finished</status> <type>validating</type> <job href="/ovirt-engine/api/jobs/123" id="123"/> </step> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StepService:%s' % self._path
A service to manage a step.
View Source
def __init__(self, connection, path): super(StepService, self).__init__(connection, path) self._statistics_service = None
Creates a new service that will use the given connection and path.
#
def
end(
self,
async_=None,
force=None,
succeeded=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def end( self, async_=None, force=None, succeeded=None, headers=None, query=None, wait=True, **kwargs ): """ Marks an external step execution as ended. For example, to terminate a step with identifier `456` which belongs to a `job` with identifier `123` send the following request: [source] ---- POST /ovirt-engine/api/jobs/123/steps/456/end ---- With the following request body: [source,xml] ---- <action> <force>true</force> <succeeded>true</succeeded> </action> ---- This method supports the following parameters: `force`:: Indicates if the step should be forcibly terminated. `succeeded`:: Indicates if the step should be marked as successfully finished or as failed. This parameter is optional, and the default value is `true`. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('succeeded', succeeded, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, succeeded=succeeded, ) # Send the request and wait for the response: return self._internal_action(action, 'end', None, headers, query, wait)
Marks an external step execution as ended.
For example, to terminate a step with identifier 456 which belongs to a job with identifier 123 send the
following request:
[source]
POST /ovirt-engine/api/jobs/123/steps/456/end
With the following request body:
[source,xml]
This method supports the following parameters:
force:: Indicates if the step should be forcibly terminated.
succeeded:: Indicates if the step should be marked as successfully finished or as failed.
This parameter is optional, and the default value is true.
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves a step. [source] ---- GET /ovirt-engine/api/jobs/123/steps/456 ---- You will receive response in XML like this one: [source,xml] ---- <step href="/ovirt-engine/api/jobs/123/steps/456" id="456"> <actions> <link href="/ovirt-engine/api/jobs/123/steps/456/end" rel="end"/> </actions> <description>Validating</description> <end_time>2016-12-12T23:07:26.627+02:00</end_time> <external>false</external> <number>0</number> <start_time>2016-12-12T23:07:26.605+02:00</start_time> <status>finished</status> <type>validating</type> <job href="/ovirt-engine/api/jobs/123" id="123"/> </step> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves a step.
[source]
GET /ovirt-engine/api/jobs/123/steps/456
You will receive response in XML like this one:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StepsService(Service): """ A service to manage steps. """ def __init__(self, connection, path): super(StepsService, self).__init__(connection, path) self._step_service = None def add( self, step, headers=None, query=None, wait=True, **kwargs ): """ Add an external step to an existing job or to an existing step. For example, to add a step to `job` with identifier `123` send the following request: [source] ---- POST /ovirt-engine/api/jobs/123/steps ---- With the following request body: [source,xml] ---- <step> <description>Validating</description> <start_time>2016-12-12T23:07:26.605+02:00</start_time> <status>started</status> <type>validating</type> </step> ---- The response should look like: [source,xml] ---- <step href="/ovirt-engine/api/jobs/123/steps/456" id="456"> <actions> <link href="/ovirt-engine/api/jobs/123/steps/456/end" rel="end"/> </actions> <description>Validating</description> <link href="/ovirt-engine/api/jobs/123/steps/456/statistics" rel="statistics"/> <external>true</external> <number>2</number> <start_time>2016-12-13T01:06:15.380+02:00</start_time> <status>started</status> <type>validating</type> <job href="/ovirt-engine/api/jobs/123" id="123"/> </step> ---- This method supports the following parameters: `step`:: Step that will be added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('step', step, types.Step), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(step, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representation of the steps. [source] ---- GET /ovirt-engine/api/job/123/steps ---- You will receive response in XML like this one: [source,xml] ---- <steps> <step href="/ovirt-engine/api/jobs/123/steps/456" id="456"> <actions> <link href="/ovirt-engine/api/jobs/123/steps/456/end" rel="end"/> </actions> <description>Validating</description> <link href="/ovirt-engine/api/jobs/123/steps/456/statistics" rel="statistics"/> <external>true</external> <number>2</number> <start_time>2016-12-13T01:06:15.380+02:00</start_time> <status>started</status> <type>validating</type> <job href="/ovirt-engine/api/jobs/123" id="123"/> </step> ... </steps> ---- The order of the returned list of steps isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of steps to return. If not specified all the steps are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def step_service(self, id): """ Reference to the step service. """ Service._check_types([ ('id', id, str), ]) return StepService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.step_service(path) return self.step_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StepsService:%s' % self._path
A service to manage steps.
View Source
def __init__(self, connection, path): super(StepsService, self).__init__(connection, path) self._step_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, step, headers=None, query=None, wait=True, **kwargs ): """ Add an external step to an existing job or to an existing step. For example, to add a step to `job` with identifier `123` send the following request: [source] ---- POST /ovirt-engine/api/jobs/123/steps ---- With the following request body: [source,xml] ---- <step> <description>Validating</description> <start_time>2016-12-12T23:07:26.605+02:00</start_time> <status>started</status> <type>validating</type> </step> ---- The response should look like: [source,xml] ---- <step href="/ovirt-engine/api/jobs/123/steps/456" id="456"> <actions> <link href="/ovirt-engine/api/jobs/123/steps/456/end" rel="end"/> </actions> <description>Validating</description> <link href="/ovirt-engine/api/jobs/123/steps/456/statistics" rel="statistics"/> <external>true</external> <number>2</number> <start_time>2016-12-13T01:06:15.380+02:00</start_time> <status>started</status> <type>validating</type> <job href="/ovirt-engine/api/jobs/123" id="123"/> </step> ---- This method supports the following parameters: `step`:: Step that will be added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('step', step, types.Step), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(step, headers, query, wait)
Add an external step to an existing job or to an existing step.
For example, to add a step to job with identifier 123 send the
following request:
[source]
POST /ovirt-engine/api/jobs/123/steps
With the following request body:
[source,xml]
The response should look like:
[source,xml]
This method supports the following parameters:
step:: Step that will be added.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representation of the steps. [source] ---- GET /ovirt-engine/api/job/123/steps ---- You will receive response in XML like this one: [source,xml] ---- <steps> <step href="/ovirt-engine/api/jobs/123/steps/456" id="456"> <actions> <link href="/ovirt-engine/api/jobs/123/steps/456/end" rel="end"/> </actions> <description>Validating</description> <link href="/ovirt-engine/api/jobs/123/steps/456/statistics" rel="statistics"/> <external>true</external> <number>2</number> <start_time>2016-12-13T01:06:15.380+02:00</start_time> <status>started</status> <type>validating</type> <job href="/ovirt-engine/api/jobs/123" id="123"/> </step> ... </steps> ---- The order of the returned list of steps isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of steps to return. If not specified all the steps are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the representation of the steps.
[source]
GET /ovirt-engine/api/job/123/steps
You will receive response in XML like this one:
[source,xml]
The order of the returned list of steps isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of steps to return. If not specified all the steps are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def step_service(self, id): """ Reference to the step service. """ Service._check_types([ ('id', id, str), ]) return StepService(self._connection, '%s/%s' % (self._path, id))
Reference to the step service.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.step_service(path) return self.step_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageService(Service): """ """ def __init__(self, connection, path): super(StorageService, self).__init__(connection, path) def get( self, follow=None, report_status=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `report_status`:: Indicates if the status of the LUNs in the storage should be checked. Checking the status of the LUN is an heavy weight operation and this data is not always needed by the user. This parameter will give the option to not perform the status check of the LUNs. The default is `true` for backward compatibility. Here an example with the LUN status : [source,xml] ---- <host_storage id="360014051136c20574f743bdbd28177fd"> <logical_units> <logical_unit id="360014051136c20574f743bdbd28177fd"> <lun_mapping>0</lun_mapping> <paths>1</paths> <product_id>lun0</product_id> <serial>SLIO-ORG_lun0_1136c205-74f7-43bd-bd28-177fd5ce6993</serial> <size>10737418240</size> <status>used</status> <vendor_id>LIO-ORG</vendor_id> <volume_group_id>O9Du7I-RahN-ECe1-dZ1w-nh0b-64io-MNzIBZ</volume_group_id> </logical_unit> </logical_units> <type>iscsi</type> <host id="8bb5ade5-e988-4000-8b93-dbfc6717fe50"/> </host_storage> ---- Here an example without the LUN status : [source,xml] ---- <host_storage id="360014051136c20574f743bdbd28177fd"> <logical_units> <logical_unit id="360014051136c20574f743bdbd28177fd"> <lun_mapping>0</lun_mapping> <paths>1</paths> <product_id>lun0</product_id> <serial>SLIO-ORG_lun0_1136c205-74f7-43bd-bd28-177fd5ce6993</serial> <size>10737418240</size> <vendor_id>LIO-ORG</vendor_id> <volume_group_id>O9Du7I-RahN-ECe1-dZ1w-nh0b-64io-MNzIBZ</volume_group_id> </logical_unit> </logical_units> <type>iscsi</type> <host id="8bb5ade5-e988-4000-8b93-dbfc6717fe50"/> </host_storage> ---- `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('report_status', report_status, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if report_status is not None: report_status = Writer.render_boolean(report_status) query['report_status'] = report_status # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageService:%s' % self._path
View Source
def __init__(self, connection, path): super(StorageService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, report_status=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `report_status`:: Indicates if the status of the LUNs in the storage should be checked. Checking the status of the LUN is an heavy weight operation and this data is not always needed by the user. This parameter will give the option to not perform the status check of the LUNs. The default is `true` for backward compatibility. Here an example with the LUN status : [source,xml] ---- <host_storage id="360014051136c20574f743bdbd28177fd"> <logical_units> <logical_unit id="360014051136c20574f743bdbd28177fd"> <lun_mapping>0</lun_mapping> <paths>1</paths> <product_id>lun0</product_id> <serial>SLIO-ORG_lun0_1136c205-74f7-43bd-bd28-177fd5ce6993</serial> <size>10737418240</size> <status>used</status> <vendor_id>LIO-ORG</vendor_id> <volume_group_id>O9Du7I-RahN-ECe1-dZ1w-nh0b-64io-MNzIBZ</volume_group_id> </logical_unit> </logical_units> <type>iscsi</type> <host id="8bb5ade5-e988-4000-8b93-dbfc6717fe50"/> </host_storage> ---- Here an example without the LUN status : [source,xml] ---- <host_storage id="360014051136c20574f743bdbd28177fd"> <logical_units> <logical_unit id="360014051136c20574f743bdbd28177fd"> <lun_mapping>0</lun_mapping> <paths>1</paths> <product_id>lun0</product_id> <serial>SLIO-ORG_lun0_1136c205-74f7-43bd-bd28-177fd5ce6993</serial> <size>10737418240</size> <vendor_id>LIO-ORG</vendor_id> <volume_group_id>O9Du7I-RahN-ECe1-dZ1w-nh0b-64io-MNzIBZ</volume_group_id> </logical_unit> </logical_units> <type>iscsi</type> <host id="8bb5ade5-e988-4000-8b93-dbfc6717fe50"/> </host_storage> ---- `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('report_status', report_status, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if report_status is not None: report_status = Writer.render_boolean(report_status) query['report_status'] = report_status # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
report_status:: Indicates if the status of the LUNs in the storage should be checked.
Checking the status of the LUN is an heavy weight operation and
this data is not always needed by the user.
This parameter will give the option to not perform the status check of the LUNs.
The default is true for backward compatibility.
Here an example with the LUN status :
[source,xml]
Here an example without the LUN status :
[source,xml]
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageDomainService(Service): """ """ def __init__(self, connection, path): super(StorageDomainService, self).__init__(connection, path) self._disk_profiles_service = None self._disk_snapshots_service = None self._disks_service = None self._files_service = None self._images_service = None self._permissions_service = None self._storage_connections_service = None self._templates_service = None self._vms_service = None def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the storage domain. This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def is_attached( self, async_=None, host=None, headers=None, query=None, wait=True, **kwargs ): """ Used for querying if the storage domain is already attached to a data center using the is_attached boolean field, which is part of the storage server. IMPORTANT: Executing this API will cause the host to disconnect from the storage domain. This method supports the following parameters: `host`:: Indicates the data center's host. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('host', host, types.Host), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, host=host, ) # Send the request and wait for the response: return self._internal_action(action, 'isattached', 'is_attached', headers, query, wait) def reduce_luns( self, logical_units=None, headers=None, query=None, wait=True, **kwargs ): """ This operation reduces logical units from the storage domain. In order to do so the data stored on the provided logical units will be moved to other logical units of the storage domain and only then they will be reduced from the storage domain. For example, in order to reduce two logical units from a storage domain send a request like this: [source] ---- POST /ovirt-engine/api/storageDomains/123/reduceluns ---- With a request body like this: [source,xml] ---- <action> <logical_units> <logical_unit id="1IET_00010001"/> <logical_unit id="1IET_00010002"/> </logical_units> </action> ---- Note that this operation is only applicable to block storage domains (i.e., storage domains with the <<types/storage_type, storage type> of iSCSI or FCP). This method supports the following parameters: `logical_units`:: The logical units that need to be reduced from the storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('logical_units', logical_units, list), ]) # Populate the action: action = types.Action( logical_units=logical_units, ) # Send the request and wait for the response: return self._internal_action(action, 'reduceluns', None, headers, query, wait) def refresh_luns( self, async_=None, logical_units=None, headers=None, query=None, wait=True, **kwargs ): """ This operation refreshes the LUN size. After increasing the size of the underlying LUN on the storage server, the user can refresh the LUN size. This action forces a rescan of the provided LUNs and updates the database with the new size, if required. For example, in order to refresh the size of two LUNs send a request like this: [source] ---- POST /ovirt-engine/api/storageDomains/262b056b-aede-40f1-9666-b883eff59d40/refreshluns ---- With a request body like this: [source,xml] ---- <action> <logical_units> <logical_unit id="1IET_00010001"/> <logical_unit id="1IET_00010002"/> </logical_units> </action> ---- This method supports the following parameters: `logical_units`:: The LUNs that need to be refreshed. `async_`:: Indicates if the refresh should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('logical_units', logical_units, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, logical_units=logical_units, ) # Send the request and wait for the response: return self._internal_action(action, 'refreshluns', None, headers, query, wait) def remove( self, host=None, format=None, destroy=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the storage domain. Without any special parameters, the storage domain is detached from the system and removed from the database. The storage domain can then be imported to the same or to a different setup, with all the data on it. If the storage is not accessible the operation will fail. If the `destroy` parameter is `true` then the operation will always succeed, even if the storage is not accessible, the failure is just ignored and the storage domain is removed from the database anyway. If the `format` parameter is `true` then the actual storage is formatted, and the metadata is removed from the LUN or directory, so it can no longer be imported to the same or to a different setup. This method supports the following parameters: `host`:: Indicates which host should be used to remove the storage domain. This parameter is mandatory, except if the `destroy` parameter is included and its value is `true`, in that case the `host` parameter will be ignored. The value should contain the name or the identifier of the host. For example, to use the host named `myhost` to remove the storage domain with identifier `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/storageDomains/123?host=myhost ---- `format`:: Indicates if the actual storage should be formatted, removing all the metadata from the underlying LUN or directory: [source] ---- DELETE /ovirt-engine/api/storageDomains/123?format=true ---- This parameter is optional, and the default value is `false`. `destroy`:: Indicates if the operation should succeed, and the storage domain removed from the database, even if the storage is not accessible. [source] ---- DELETE /ovirt-engine/api/storageDomains/123?destroy=true ---- This parameter is optional, and the default value is `false`. When the value of `destroy` is `true` the `host` parameter will be ignored. `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, str), ('format', format, bool), ('destroy', destroy, bool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if host is not None: query['host'] = host if format is not None: format = Writer.render_boolean(format) query['format'] = format if destroy is not None: destroy = Writer.render_boolean(destroy) query['destroy'] = destroy if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, storage_domain, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a storage domain. Not all of the <<types/storage_domain,StorageDomain>>'s attributes are updatable after creation. Those that can be updated are: `name`, `description`, `comment`, `warning_low_space_indicator`, `critical_space_action_blocker` and `wipe_after_delete.` (Note that changing the `wipe_after_delete` attribute will not change the wipe after delete property of disks that already exist). To update the `name` and `wipe_after_delete` attributes of a storage domain with an identifier `123`, send a request as follows: [source] ---- PUT /ovirt-engine/api/storageDomains/123 ---- With a request body as follows: [source,xml] ---- <storage_domain> <name>data2</name> <wipe_after_delete>true</wipe_after_delete> </storage_domain> ---- This method supports the following parameters: `storage_domain`:: The updated storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(storage_domain, headers, query, wait) def update_ovf_store( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation forces the update of the `OVF_STORE` of this storage domain. The `OVF_STORE` is a disk image that contains the metadata of virtual machines and disks that reside in the storage domain. This metadata is used in case the domain is imported or exported to or from a different data center or a different installation. By default the `OVF_STORE` is updated periodically (set by default to 60 minutes) but users might want to force an update after an important change, or when the they believe the `OVF_STORE` is corrupt. When initiated by the user, `OVF_STORE` update will be performed whether an update is needed or not. This method supports the following parameters: `async_`:: Indicates if the `OVF_STORE` update should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'updateovfstore', None, headers, query, wait) def disk_profiles_service(self): """ """ return AssignedDiskProfilesService(self._connection, '%s/diskprofiles' % self._path) def disk_snapshots_service(self): """ """ return DiskSnapshotsService(self._connection, '%s/disksnapshots' % self._path) def disks_service(self): """ Reference to the service that manages the disks available in the storage domain. """ return StorageDomainDisksService(self._connection, '%s/disks' % self._path) def files_service(self): """ Returns a reference to the service that manages the files available in the storage domain. """ return FilesService(self._connection, '%s/files' % self._path) def images_service(self): """ """ return ImagesService(self._connection, '%s/images' % self._path) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def storage_connections_service(self): """ Returns a reference to the service that manages the storage connections. """ return StorageDomainServerConnectionsService(self._connection, '%s/storageconnections' % self._path) def templates_service(self): """ """ return StorageDomainTemplatesService(self._connection, '%s/templates' % self._path) def vms_service(self): """ """ return StorageDomainVmsService(self._connection, '%s/vms' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'diskprofiles': return self.disk_profiles_service() if path.startswith('diskprofiles/'): return self.disk_profiles_service().service(path[13:]) if path == 'disksnapshots': return self.disk_snapshots_service() if path.startswith('disksnapshots/'): return self.disk_snapshots_service().service(path[14:]) if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) if path == 'files': return self.files_service() if path.startswith('files/'): return self.files_service().service(path[6:]) if path == 'images': return self.images_service() if path.startswith('images/'): return self.images_service().service(path[7:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'storageconnections': return self.storage_connections_service() if path.startswith('storageconnections/'): return self.storage_connections_service().service(path[19:]) if path == 'templates': return self.templates_service() if path.startswith('templates/'): return self.templates_service().service(path[10:]) if path == 'vms': return self.vms_service() if path.startswith('vms/'): return self.vms_service().service(path[4:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageDomainService:%s' % self._path
View Source
def __init__(self, connection, path): super(StorageDomainService, self).__init__(connection, path) self._disk_profiles_service = None self._disk_snapshots_service = None self._disks_service = None self._files_service = None self._images_service = None self._permissions_service = None self._storage_connections_service = None self._templates_service = None self._vms_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the storage domain. This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the description of the storage domain.
This method supports the following parameters:
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def is_attached( self, async_=None, host=None, headers=None, query=None, wait=True, **kwargs ): """ Used for querying if the storage domain is already attached to a data center using the is_attached boolean field, which is part of the storage server. IMPORTANT: Executing this API will cause the host to disconnect from the storage domain. This method supports the following parameters: `host`:: Indicates the data center's host. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('host', host, types.Host), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, host=host, ) # Send the request and wait for the response: return self._internal_action(action, 'isattached', 'is_attached', headers, query, wait)
Used for querying if the storage domain is already attached to a data center using the is_attached boolean field, which is part of the storage server. IMPORTANT: Executing this API will cause the host to disconnect from the storage domain.
This method supports the following parameters:
host:: Indicates the data center's host.
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def reduce_luns( self, logical_units=None, headers=None, query=None, wait=True, **kwargs ): """ This operation reduces logical units from the storage domain. In order to do so the data stored on the provided logical units will be moved to other logical units of the storage domain and only then they will be reduced from the storage domain. For example, in order to reduce two logical units from a storage domain send a request like this: [source] ---- POST /ovirt-engine/api/storageDomains/123/reduceluns ---- With a request body like this: [source,xml] ---- <action> <logical_units> <logical_unit id="1IET_00010001"/> <logical_unit id="1IET_00010002"/> </logical_units> </action> ---- Note that this operation is only applicable to block storage domains (i.e., storage domains with the <<types/storage_type, storage type> of iSCSI or FCP). This method supports the following parameters: `logical_units`:: The logical units that need to be reduced from the storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('logical_units', logical_units, list), ]) # Populate the action: action = types.Action( logical_units=logical_units, ) # Send the request and wait for the response: return self._internal_action(action, 'reduceluns', None, headers, query, wait)
This operation reduces logical units from the storage domain. In order to do so the data stored on the provided logical units will be moved to other logical units of the storage domain and only then they will be reduced from the storage domain. For example, in order to reduce two logical units from a storage domain send a request like this:
[source]
POST /ovirt-engine/api/storageDomains/123/reduceluns
With a request body like this:
[source,xml]
Note that this operation is only applicable to block storage domains (i.e., storage domains with the
<
This method supports the following parameters:
logical_units:: The logical units that need to be reduced from the storage domain.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
refresh_luns(
self,
async_=None,
logical_units=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def refresh_luns( self, async_=None, logical_units=None, headers=None, query=None, wait=True, **kwargs ): """ This operation refreshes the LUN size. After increasing the size of the underlying LUN on the storage server, the user can refresh the LUN size. This action forces a rescan of the provided LUNs and updates the database with the new size, if required. For example, in order to refresh the size of two LUNs send a request like this: [source] ---- POST /ovirt-engine/api/storageDomains/262b056b-aede-40f1-9666-b883eff59d40/refreshluns ---- With a request body like this: [source,xml] ---- <action> <logical_units> <logical_unit id="1IET_00010001"/> <logical_unit id="1IET_00010002"/> </logical_units> </action> ---- This method supports the following parameters: `logical_units`:: The LUNs that need to be refreshed. `async_`:: Indicates if the refresh should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('logical_units', logical_units, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, logical_units=logical_units, ) # Send the request and wait for the response: return self._internal_action(action, 'refreshluns', None, headers, query, wait)
This operation refreshes the LUN size. After increasing the size of the underlying LUN on the storage server, the user can refresh the LUN size. This action forces a rescan of the provided LUNs and updates the database with the new size, if required. For example, in order to refresh the size of two LUNs send a request like this:
[source]
POST /ovirt-engine/api/storageDomains/262b056b-aede-40f1-9666-b883eff59d40/refreshluns
With a request body like this:
[source,xml]
This method supports the following parameters:
logical_units:: The LUNs that need to be refreshed.
async_:: Indicates if the refresh should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
remove(
self,
host=None,
format=None,
destroy=None,
async_=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def remove( self, host=None, format=None, destroy=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the storage domain. Without any special parameters, the storage domain is detached from the system and removed from the database. The storage domain can then be imported to the same or to a different setup, with all the data on it. If the storage is not accessible the operation will fail. If the `destroy` parameter is `true` then the operation will always succeed, even if the storage is not accessible, the failure is just ignored and the storage domain is removed from the database anyway. If the `format` parameter is `true` then the actual storage is formatted, and the metadata is removed from the LUN or directory, so it can no longer be imported to the same or to a different setup. This method supports the following parameters: `host`:: Indicates which host should be used to remove the storage domain. This parameter is mandatory, except if the `destroy` parameter is included and its value is `true`, in that case the `host` parameter will be ignored. The value should contain the name or the identifier of the host. For example, to use the host named `myhost` to remove the storage domain with identifier `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/storageDomains/123?host=myhost ---- `format`:: Indicates if the actual storage should be formatted, removing all the metadata from the underlying LUN or directory: [source] ---- DELETE /ovirt-engine/api/storageDomains/123?format=true ---- This parameter is optional, and the default value is `false`. `destroy`:: Indicates if the operation should succeed, and the storage domain removed from the database, even if the storage is not accessible. [source] ---- DELETE /ovirt-engine/api/storageDomains/123?destroy=true ---- This parameter is optional, and the default value is `false`. When the value of `destroy` is `true` the `host` parameter will be ignored. `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, str), ('format', format, bool), ('destroy', destroy, bool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if host is not None: query['host'] = host if format is not None: format = Writer.render_boolean(format) query['format'] = format if destroy is not None: destroy = Writer.render_boolean(destroy) query['destroy'] = destroy if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the storage domain.
Without any special parameters, the storage domain is detached from the system and removed from the database. The
storage domain can then be imported to the same or to a different setup, with all the data on it. If the storage is
not accessible the operation will fail.
If the destroy parameter is true then the operation will always succeed, even if the storage is not
accessible, the failure is just ignored and the storage domain is removed from the database anyway.
If the format parameter is true then the actual storage is formatted, and the metadata is removed from the
LUN or directory, so it can no longer be imported to the same or to a different setup.
This method supports the following parameters:
host:: Indicates which host should be used to remove the storage domain.
This parameter is mandatory, except if the destroy parameter is included and its value is true, in that
case the host parameter will be ignored.
The value should contain the name or the identifier of the host. For example, to use the host named myhost
to remove the storage domain with identifier 123 send a request like this:
[source]
DELETE /ovirt-engine/api/storageDomains/123?host=myhost
format:: Indicates if the actual storage should be formatted, removing all the metadata from the underlying LUN or
directory:
[source]
DELETE /ovirt-engine/api/storageDomains/123?format=true
This parameter is optional, and the default value is false.
destroy:: Indicates if the operation should succeed, and the storage domain removed from the database, even if the
storage is not accessible.
[source]
DELETE /ovirt-engine/api/storageDomains/123?destroy=true
This parameter is optional, and the default value is false.
When the value of destroy is true the host parameter will be ignored.
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, storage_domain, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a storage domain. Not all of the <<types/storage_domain,StorageDomain>>'s attributes are updatable after creation. Those that can be updated are: `name`, `description`, `comment`, `warning_low_space_indicator`, `critical_space_action_blocker` and `wipe_after_delete.` (Note that changing the `wipe_after_delete` attribute will not change the wipe after delete property of disks that already exist). To update the `name` and `wipe_after_delete` attributes of a storage domain with an identifier `123`, send a request as follows: [source] ---- PUT /ovirt-engine/api/storageDomains/123 ---- With a request body as follows: [source,xml] ---- <storage_domain> <name>data2</name> <wipe_after_delete>true</wipe_after_delete> </storage_domain> ---- This method supports the following parameters: `storage_domain`:: The updated storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(storage_domain, headers, query, wait)
Updates a storage domain.
Not all of the <name, description, comment, warning_low_space_indicator, critical_space_action_blocker and
wipe_after_delete. (Note that changing the wipe_after_delete attribute will not change the wipe after delete
property of disks that already exist).
To update the name and wipe_after_delete attributes of a storage domain with an identifier 123, send a
request as follows:
[source]
PUT /ovirt-engine/api/storageDomains/123
With a request body as follows:
[source,xml]
This method supports the following parameters:
storage_domain:: The updated storage domain.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update_ovf_store( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation forces the update of the `OVF_STORE` of this storage domain. The `OVF_STORE` is a disk image that contains the metadata of virtual machines and disks that reside in the storage domain. This metadata is used in case the domain is imported or exported to or from a different data center or a different installation. By default the `OVF_STORE` is updated periodically (set by default to 60 minutes) but users might want to force an update after an important change, or when the they believe the `OVF_STORE` is corrupt. When initiated by the user, `OVF_STORE` update will be performed whether an update is needed or not. This method supports the following parameters: `async_`:: Indicates if the `OVF_STORE` update should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'updateovfstore', None, headers, query, wait)
This operation forces the update of the OVF_STORE
of this storage domain.
The OVF_STORE is a disk image that contains the metadata
of virtual machines and disks that reside in the
storage domain. This metadata is used in case the
domain is imported or exported to or from a different
data center or a different installation.
By default the OVF_STORE is updated periodically
(set by default to 60 minutes) but users might want to force an
update after an important change, or when the they believe the
OVF_STORE is corrupt.
When initiated by the user, OVF_STORE update will be performed whether
an update is needed or not.
This method supports the following parameters:
async_:: Indicates if the OVF_STORE update should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disk_profiles_service(self): """ """ return AssignedDiskProfilesService(self._connection, '%s/diskprofiles' % self._path)
View Source
def disk_snapshots_service(self): """ """ return DiskSnapshotsService(self._connection, '%s/disksnapshots' % self._path)
View Source
def disks_service(self): """ Reference to the service that manages the disks available in the storage domain. """ return StorageDomainDisksService(self._connection, '%s/disks' % self._path)
Reference to the service that manages the disks available in the storage domain.
View Source
def files_service(self): """ Returns a reference to the service that manages the files available in the storage domain. """ return FilesService(self._connection, '%s/files' % self._path)
Returns a reference to the service that manages the files available in the storage domain.
View Source
def images_service(self): """ """ return ImagesService(self._connection, '%s/images' % self._path)
View Source
def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
View Source
def storage_connections_service(self): """ Returns a reference to the service that manages the storage connections. """ return StorageDomainServerConnectionsService(self._connection, '%s/storageconnections' % self._path)
Returns a reference to the service that manages the storage connections.
View Source
def templates_service(self): """ """ return StorageDomainTemplatesService(self._connection, '%s/templates' % self._path)
View Source
def vms_service(self): """ """ return StorageDomainVmsService(self._connection, '%s/vms' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'diskprofiles': return self.disk_profiles_service() if path.startswith('diskprofiles/'): return self.disk_profiles_service().service(path[13:]) if path == 'disksnapshots': return self.disk_snapshots_service() if path.startswith('disksnapshots/'): return self.disk_snapshots_service().service(path[14:]) if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) if path == 'files': return self.files_service() if path.startswith('files/'): return self.files_service().service(path[6:]) if path == 'images': return self.images_service() if path.startswith('images/'): return self.images_service().service(path[7:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'storageconnections': return self.storage_connections_service() if path.startswith('storageconnections/'): return self.storage_connections_service().service(path[19:]) if path == 'templates': return self.templates_service() if path.startswith('templates/'): return self.templates_service().service(path[10:]) if path == 'vms': return self.vms_service() if path.startswith('vms/'): return self.vms_service().service(path[4:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageDomainContentDiskService(Service): """ """ def __init__(self, connection, path): super(StorageDomainContentDiskService, self).__init__(connection, path) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageDomainContentDiskService:%s' % self._path
View Source
def __init__(self, connection, path): super(StorageDomainContentDiskService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageDomainContentDisksService(Service): """ Manages the set of disks available in a storage domain. """ def __init__(self, connection, path): super(StorageDomainContentDisksService, self).__init__(connection, path) self._disk_service = None def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks available in the storage domain. The order of the returned list of disks is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `search`:: A query string used to restrict the returned disks. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainContentDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageDomainContentDisksService:%s' % self._path
Manages the set of disks available in a storage domain.
View Source
def __init__(self, connection, path): super(StorageDomainContentDisksService, self).__init__(connection, path) self._disk_service = None
Creates a new service that will use the given connection and path.
#
def
list(
self,
case_sensitive=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks available in the storage domain. The order of the returned list of disks is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `search`:: A query string used to restrict the returned disks. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of disks available in the storage domain.
The order of the returned list of disks is guaranteed only if the sortby clause is included in
the search parameter.
This method supports the following parameters:
max:: Sets the maximum number of disks to return. If not specified all the disks are returned.
search:: A query string used to restrict the returned disks.
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disk_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainContentDiskService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageDomainDiskService(MeasurableService): """ Manages a single disk available in a storage domain. IMPORTANT: Since version 4.2 of the engine this service is intended only to list disks available in the storage domain, and to register unregistered disks. All the other operations, like copying a disk, moving a disk, etc, have been deprecated and will be removed in the future. To perform those operations use the <<services/disks, service that manages all the disks of the system>>, or the <<services/disk, service that manages an specific disk>>. """ def __init__(self, connection, path): super(StorageDomainDiskService, self).__init__(connection, path) self._permissions_service = None self._statistics_service = None def copy( self, disk=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Copies a disk to the specified storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To copy a disk use the <<services/disk/methods/copy, copy>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: Description of the resulting disk. `storage_domain`:: The storage domain where the new disk will be created. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( disk=disk, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait) def export( self, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a disk to an export storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To export a disk use the <<services/disk/methods/export, export>> operation of the service that manages that disk. This method supports the following parameters: `storage_domain`:: The export storage domain where the disk should be exported to. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def move( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Moves a disk to another storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To move a disk use the <<services/disk/methods/move, move>> operation of the service that manages that disk. This method supports the following parameters: `storage_domain`:: The storage domain where the disk will be moved to. `async_`:: Indicates if the move should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait) def reduce( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Reduces the size of the disk image. Invokes _reduce_ on the logical volume (i.e. this is only applicable for block storage domains). This is applicable for floating disks and disks attached to non-running virtual machines. There is no need to specify the size as the optimal size is calculated automatically. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reduce', None, headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes a disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To remove a disk use the <<services/disk/methods/remove, remove>> operation of the service that manages that disk. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def sparsify( self, headers=None, query=None, wait=True, **kwargs ): """ Sparsify the disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To remove a disk use the <<services/disk/methods/remove, remove>> operation of the service that manages that disk. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'sparsify', None, headers, query, wait) def update( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Updates the disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To update a disk use the <<services/disk/methods/update, update>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: The update to apply to the disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(disk, headers, query, wait) def permissions_service(self): """ Reference to the service that manages the permissions assigned to the disk. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageDomainDiskService:%s' % self._path
Manages a single disk available in a storage domain.
IMPORTANT: Since version 4.2 of the engine this service is intended only to list disks available in the storage
domain, and to register unregistered disks. All the other operations, like copying a disk, moving a disk, etc, have
been deprecated and will be removed in the future. To perform those operations use the <
View Source
def __init__(self, connection, path): super(StorageDomainDiskService, self).__init__(connection, path) self._permissions_service = None self._statistics_service = None
Creates a new service that will use the given connection and path.
View Source
def copy( self, disk=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Copies a disk to the specified storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To copy a disk use the <<services/disk/methods/copy, copy>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: Description of the resulting disk. `storage_domain`:: The storage domain where the new disk will be created. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( disk=disk, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait)
Copies a disk to the specified storage domain.
IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. To copy a disk use the <
This method supports the following parameters:
disk:: Description of the resulting disk.
storage_domain:: The storage domain where the new disk will be created.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def export( self, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a disk to an export storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To export a disk use the <<services/disk/methods/export, export>> operation of the service that manages that disk. This method supports the following parameters: `storage_domain`:: The export storage domain where the disk should be exported to. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait)
Exports a disk to an export storage domain.
IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. To export a disk use the <
This method supports the following parameters:
storage_domain:: The export storage domain where the disk should be exported to.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the description of the disk.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
move(
self,
async_=None,
filter=None,
storage_domain=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def move( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Moves a disk to another storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To move a disk use the <<services/disk/methods/move, move>> operation of the service that manages that disk. This method supports the following parameters: `storage_domain`:: The storage domain where the disk will be moved to. `async_`:: Indicates if the move should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait)
Moves a disk to another storage domain.
IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. To move a disk use the <
This method supports the following parameters:
storage_domain:: The storage domain where the disk will be moved to.
async_:: Indicates if the move should be performed asynchronously.
filter:: Indicates if the results should be filtered according to the permissions of the user.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def reduce( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Reduces the size of the disk image. Invokes _reduce_ on the logical volume (i.e. this is only applicable for block storage domains). This is applicable for floating disks and disks attached to non-running virtual machines. There is no need to specify the size as the optimal size is calculated automatically. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reduce', None, headers, query, wait)
Reduces the size of the disk image. Invokes _reduce_ on the logical volume (i.e. this is only applicable for block storage domains). This is applicable for floating disks and disks attached to non-running virtual machines. There is no need to specify the size as the optimal size is calculated automatically.
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes a disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To remove a disk use the <<services/disk/methods/remove, remove>> operation of the service that manages that disk. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes a disk.
IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. To remove a disk use the <
View Source
def sparsify( self, headers=None, query=None, wait=True, **kwargs ): """ Sparsify the disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To remove a disk use the <<services/disk/methods/remove, remove>> operation of the service that manages that disk. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'sparsify', None, headers, query, wait)
Sparsify the disk.
IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. To remove a disk use the <
View Source
def update( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Updates the disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To update a disk use the <<services/disk/methods/update, update>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: The update to apply to the disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(disk, headers, query, wait)
Updates the disk.
IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. To update a disk use the
<
This method supports the following parameters:
disk:: The update to apply to the disk.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def permissions_service(self): """ Reference to the service that manages the permissions assigned to the disk. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
Reference to the service that manages the permissions assigned to the disk.
View Source
def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageDomainDisksService(Service): """ Manages the collection of disks available inside a specific storage domain. """ def __init__(self, connection, path): super(StorageDomainDisksService, self).__init__(connection, path) self._disk_service = None def add( self, disk, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Adds or registers a disk. IMPORTANT: Since version 4.2 of the {engine-name} this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To add a new disk use the <<services/disks/methods/add, add>> operation of the service that manages the disks of the system. To register an unregistered disk use the <<services/attached_storage_domain_disk/methods/register, register>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: The disk to add or register. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait) def list( self, follow=None, max=None, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the list of disks that are available in the storage domain. The order of the returned list of disks is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified, all the disks are returned. `unregistered`:: Indicates whether to retrieve a list of registered or unregistered disks in the storage domain. To get a list of unregistered disks in the storage domain the call should indicate the unregistered flag. For example, to get a list of unregistered disks the REST API call should look like this: .... GET /ovirt-engine/api/storagedomains/123/disks?unregistered=true .... The default value of the unregistered flag is `false`. The request only applies to storage domains that are attached. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ A reference to the service that manages a specific disk. """ Service._check_types([ ('id', id, str), ]) return StorageDomainDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageDomainDisksService:%s' % self._path
Manages the collection of disks available inside a specific storage domain.
View Source
def __init__(self, connection, path): super(StorageDomainDisksService, self).__init__(connection, path) self._disk_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, disk, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Adds or registers a disk. IMPORTANT: Since version 4.2 of the {engine-name} this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To add a new disk use the <<services/disks/methods/add, add>> operation of the service that manages the disks of the system. To register an unregistered disk use the <<services/attached_storage_domain_disk/methods/register, register>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: The disk to add or register. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait)
Adds or registers a disk.
IMPORTANT: Since version 4.2 of the {engine-name} this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. To add a new disk use the <
This method supports the following parameters:
disk:: The disk to add or register.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
list(
self,
follow=None,
max=None,
unregistered=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, follow=None, max=None, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the list of disks that are available in the storage domain. The order of the returned list of disks is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified, all the disks are returned. `unregistered`:: Indicates whether to retrieve a list of registered or unregistered disks in the storage domain. To get a list of unregistered disks in the storage domain the call should indicate the unregistered flag. For example, to get a list of unregistered disks the REST API call should look like this: .... GET /ovirt-engine/api/storagedomains/123/disks?unregistered=true .... The default value of the unregistered flag is `false`. The request only applies to storage domains that are attached. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the list of disks that are available in the storage domain. The order of the returned list of disks is not guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of disks to return. If not specified, all the disks are returned.
unregistered:: Indicates whether to retrieve a list of registered or unregistered disks in the storage domain.
To get a list of unregistered disks in the storage domain the call should indicate the unregistered flag.
For example, to get a list of unregistered disks the REST API call should look like this:
....
GET /ovirt-engine/api/storagedomains/123/disks?unregistered=true
....
The default value of the unregistered flag is false.
The request only applies to storage domains that are attached.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disk_service(self, id): """ A reference to the service that manages a specific disk. """ Service._check_types([ ('id', id, str), ]) return StorageDomainDiskService(self._connection, '%s/%s' % (self._path, id))
A reference to the service that manages a specific disk.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageDomainServerConnectionService(Service): """ """ def __init__(self, connection, path): super(StorageDomainServerConnectionService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Detaches a storage connection from storage. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageDomainServerConnectionService:%s' % self._path
View Source
def __init__(self, connection, path): super(StorageDomainServerConnectionService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Detaches a storage connection from storage. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Detaches a storage connection from storage.
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageDomainServerConnectionsService(Service): """ Manages the set of connections to storage servers that exist in a storage domain. """ def __init__(self, connection, path): super(StorageDomainServerConnectionsService, self).__init__(connection, path) self._connection_service = None def add( self, connection, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of connections to storage servers that existin the storage domain. The order of the returned list of connections isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of connections to return. If not specified all the connections are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def connection_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainServerConnectionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.connection_service(path) return self.connection_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageDomainServerConnectionsService:%s' % self._path
Manages the set of connections to storage servers that exist in a storage domain.
View Source
def __init__(self, connection, path): super(StorageDomainServerConnectionsService, self).__init__(connection, path) self._connection_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, connection, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait)
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of connections to storage servers that existin the storage domain. The order of the returned list of connections isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of connections to return. If not specified all the connections are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of connections to storage servers that existin the storage domain. The order of the returned list of connections isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of connections to return. If not specified all the connections are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def connection_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainServerConnectionService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.connection_service(path) return self.connection_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageDomainTemplateService(Service): """ """ def __init__(self, connection, path): super(StorageDomainTemplateService, self).__init__(connection, path) self._disks_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_( self, async_=None, clone=None, cluster=None, exclusive=None, storage_domain=None, template=None, vm=None, headers=None, query=None, wait=True, **kwargs ): """ Action to import a template from an export storage domain. For example, to import the template `456` from the storage domain `123` send the following request: [source] ---- POST /ovirt-engine/api/storagedomains/123/templates/456/import ---- With the following request body: [source, xml] ---- <action> <storage_domain> <name>myexport</name> </storage_domain> <cluster> <name>mycluster</name> </cluster> </action> ---- If you register an entity without specifying the cluster ID or name, the cluster name from the entity's OVF will be used (unless the register request also includes the cluster mapping). This method supports the following parameters: `clone`:: Use the optional `clone` parameter to generate new UUIDs for the imported template and its entities. You can import a template with the `clone` parameter set to `false` when importing a template from an export domain, with templates that were exported by a different {product-name} environment. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('clone', clone, bool), ('cluster', cluster, types.Cluster), ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ('template', template, types.Template), ('vm', vm, types.Vm), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, clone=clone, cluster=cluster, exclusive=exclusive, storage_domain=storage_domain, template=template, vm=vm, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait) def register( self, allow_partial_import=None, async_=None, clone=None, cluster=None, exclusive=None, registration_configuration=None, template=None, vnic_profile_mappings=None, headers=None, query=None, wait=True, **kwargs ): """ Register the Template means importing the Template from the data domain by inserting the configuration of the Template and disks into the database without the copy process. This method supports the following parameters: `allow_partial_import`:: Indicates whether a template is allowed to be registered with only some of its disks. If this flag is `true`, the system will not fail in the validation process if an image is not found, but instead it will allow the template to be registered without the missing disks. This is mainly used during registration of a template when some of the storage domains are not available. The default value is `false`. `vnic_profile_mappings`:: Deprecated attribute describing mapping rules for virtual NIC profiles that will be applied during the import\register process. WARNING: Please note that this attribute has been deprecated since version 4.2.1 of the engine, and preserved only for backward compatibility. It will be removed in the future. To specify `vnic_profile_mappings` use the `vnic_profile_mappings` attribute inside the <<types/registration_configuration, RegistrationConfiguration>> type. `registration_configuration`:: This parameter describes how the template should be registered. This parameter is optional. If the parameter is not specified, the template will be registered with the same configuration that it had in the original environment where it was created. `async_`:: Indicates if the registration should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('allow_partial_import', allow_partial_import, bool), ('async_', async_, bool), ('clone', clone, bool), ('cluster', cluster, types.Cluster), ('exclusive', exclusive, bool), ('registration_configuration', registration_configuration, types.RegistrationConfiguration), ('template', template, types.Template), ('vnic_profile_mappings', vnic_profile_mappings, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( allow_partial_import=allow_partial_import, async_=async_, clone=clone, cluster=cluster, exclusive=exclusive, registration_configuration=registration_configuration, template=template, vnic_profile_mappings=vnic_profile_mappings, ) # Send the request and wait for the response: return self._internal_action(action, 'register', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def disks_service(self): """ """ return StorageDomainContentDisksService(self._connection, '%s/disks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageDomainTemplateService:%s' % self._path
View Source
def __init__(self, connection, path): super(StorageDomainTemplateService, self).__init__(connection, path) self._disks_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
import_(
self,
async_=None,
clone=None,
cluster=None,
exclusive=None,
storage_domain=None,
template=None,
vm=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def import_( self, async_=None, clone=None, cluster=None, exclusive=None, storage_domain=None, template=None, vm=None, headers=None, query=None, wait=True, **kwargs ): """ Action to import a template from an export storage domain. For example, to import the template `456` from the storage domain `123` send the following request: [source] ---- POST /ovirt-engine/api/storagedomains/123/templates/456/import ---- With the following request body: [source, xml] ---- <action> <storage_domain> <name>myexport</name> </storage_domain> <cluster> <name>mycluster</name> </cluster> </action> ---- If you register an entity without specifying the cluster ID or name, the cluster name from the entity's OVF will be used (unless the register request also includes the cluster mapping). This method supports the following parameters: `clone`:: Use the optional `clone` parameter to generate new UUIDs for the imported template and its entities. You can import a template with the `clone` parameter set to `false` when importing a template from an export domain, with templates that were exported by a different {product-name} environment. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('clone', clone, bool), ('cluster', cluster, types.Cluster), ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ('template', template, types.Template), ('vm', vm, types.Vm), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, clone=clone, cluster=cluster, exclusive=exclusive, storage_domain=storage_domain, template=template, vm=vm, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait)
Action to import a template from an export storage domain.
For example, to import the template 456 from the storage domain 123 send the following request:
[source]
POST /ovirt-engine/api/storagedomains/123/templates/456/import
With the following request body:
[source, xml]
If you register an entity without specifying the cluster ID or name, the cluster name from the entity's OVF will be used (unless the register request also includes the cluster mapping).
This method supports the following parameters:
clone:: Use the optional clone parameter to generate new UUIDs for the imported template and its entities.
You can import a template with the clone parameter set to false when importing a template
from an export domain, with templates that were exported by a different {product-name} environment.
async_:: Indicates if the import should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
register(
self,
allow_partial_import=None,
async_=None,
clone=None,
cluster=None,
exclusive=None,
registration_configuration=None,
template=None,
vnic_profile_mappings=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def register( self, allow_partial_import=None, async_=None, clone=None, cluster=None, exclusive=None, registration_configuration=None, template=None, vnic_profile_mappings=None, headers=None, query=None, wait=True, **kwargs ): """ Register the Template means importing the Template from the data domain by inserting the configuration of the Template and disks into the database without the copy process. This method supports the following parameters: `allow_partial_import`:: Indicates whether a template is allowed to be registered with only some of its disks. If this flag is `true`, the system will not fail in the validation process if an image is not found, but instead it will allow the template to be registered without the missing disks. This is mainly used during registration of a template when some of the storage domains are not available. The default value is `false`. `vnic_profile_mappings`:: Deprecated attribute describing mapping rules for virtual NIC profiles that will be applied during the import\register process. WARNING: Please note that this attribute has been deprecated since version 4.2.1 of the engine, and preserved only for backward compatibility. It will be removed in the future. To specify `vnic_profile_mappings` use the `vnic_profile_mappings` attribute inside the <<types/registration_configuration, RegistrationConfiguration>> type. `registration_configuration`:: This parameter describes how the template should be registered. This parameter is optional. If the parameter is not specified, the template will be registered with the same configuration that it had in the original environment where it was created. `async_`:: Indicates if the registration should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('allow_partial_import', allow_partial_import, bool), ('async_', async_, bool), ('clone', clone, bool), ('cluster', cluster, types.Cluster), ('exclusive', exclusive, bool), ('registration_configuration', registration_configuration, types.RegistrationConfiguration), ('template', template, types.Template), ('vnic_profile_mappings', vnic_profile_mappings, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( allow_partial_import=allow_partial_import, async_=async_, clone=clone, cluster=cluster, exclusive=exclusive, registration_configuration=registration_configuration, template=template, vnic_profile_mappings=vnic_profile_mappings, ) # Send the request and wait for the response: return self._internal_action(action, 'register', None, headers, query, wait)
Register the Template means importing the Template from the data domain by inserting the configuration of the Template and disks into the database without the copy process.
This method supports the following parameters:
allow_partial_import:: Indicates whether a template is allowed to be registered with only some of its disks.
If this flag is true, the system will not fail in the validation process if an image is not found, but
instead it will allow the template to be registered without the missing disks. This is mainly used during
registration of a template when some of the storage domains are not available. The default value is false.
vnic_profile_mappings:: Deprecated attribute describing mapping rules for virtual NIC profiles that will be applied during the import
egister process.
WARNING: Please note that this attribute has been deprecated since version 4.2.1 of the engine, and preserved only for backward
compatibility. It will be removed in the future. To specify vnic_profile_mappings use the vnic_profile_mappings
attribute inside the <
registration_configuration:: This parameter describes how the template should be
registered.
This parameter is optional. If the parameter is not specified, the template
will be registered with the same configuration that
it had in the original environment where it was created.
async_:: Indicates if the registration should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disks_service(self): """ """ return StorageDomainContentDisksService(self._connection, '%s/disks' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageDomainTemplatesService(Service): """ Manages the set of templates available in a storage domain. """ def __init__(self, connection, path): super(StorageDomainTemplatesService, self).__init__(connection, path) self._template_service = None def list( self, follow=None, max=None, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of templates availalbe in the storage domain. The order of the returned list of templates isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of templates to return. If not specified all the templates are returned. `unregistered`:: Indicates whether to retrieve a list of registered or unregistered templates which contain disks on the storage domain. To get a list of unregistered templates the call should indicate the unregistered flag. For example, to get a list of unregistered templates the REST API call should look like this: .... GET /ovirt-engine/api/storagedomains/123/templates?unregistered=true .... The default value of the unregisterd flag is `false`. The request only apply to storage domains that are attached. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_get(headers, query, wait) def template_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainTemplateService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.template_service(path) return self.template_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageDomainTemplatesService:%s' % self._path
Manages the set of templates available in a storage domain.
View Source
def __init__(self, connection, path): super(StorageDomainTemplatesService, self).__init__(connection, path) self._template_service = None
Creates a new service that will use the given connection and path.
#
def
list(
self,
follow=None,
max=None,
unregistered=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, follow=None, max=None, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of templates availalbe in the storage domain. The order of the returned list of templates isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of templates to return. If not specified all the templates are returned. `unregistered`:: Indicates whether to retrieve a list of registered or unregistered templates which contain disks on the storage domain. To get a list of unregistered templates the call should indicate the unregistered flag. For example, to get a list of unregistered templates the REST API call should look like this: .... GET /ovirt-engine/api/storagedomains/123/templates?unregistered=true .... The default value of the unregisterd flag is `false`. The request only apply to storage domains that are attached. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of templates availalbe in the storage domain. The order of the returned list of templates isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of templates to return. If not specified all the templates are returned.
unregistered:: Indicates whether to retrieve a list of registered or unregistered templates which contain disks on the storage domain.
To get a list of unregistered templates the call should indicate the unregistered flag.
For example, to get a list of unregistered templates the REST API call should look like this:
....
GET /ovirt-engine/api/storagedomains/123/templates?unregistered=true
....
The default value of the unregisterd flag is false.
The request only apply to storage domains that are attached.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def template_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainTemplateService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.template_service(path) return self.template_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageDomainVmService(Service): """ """ def __init__(self, connection, path): super(StorageDomainVmService, self).__init__(connection, path) self._disk_attachments_service = None self._disks_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_( self, async_=None, clone=None, cluster=None, collapse_snapshots=None, exclusive=None, storage_domain=None, vm=None, headers=None, query=None, wait=True, **kwargs ): """ Imports a virtual machine from an export storage domain. For example, send a request like this: [source] ---- POST /ovirt-engine/api/storagedomains/123/vms/456/import ---- With a request body like this: [source,xml] ---- <action> <storage_domain> <name>mydata</name> </storage_domain> <cluster> <name>mycluster</name> </cluster> </action> ---- To import a virtual machine as a new entity add the `clone` parameter: [source,xml] ---- <action> <storage_domain> <name>mydata</name> </storage_domain> <cluster> <name>mycluster</name> </cluster> <clone>true</clone> <vm> <name>myvm</name> </vm> </action> ---- Include an optional `disks` parameter to choose which disks to import. For example, to import the disks of the template that have the identifiers `123` and `456` send the following request body: [source,xml] ---- <action> <cluster> <name>mycluster</name> </cluster> <vm> <name>myvm</name> </vm> <disks> <disk id="123"/> <disk id="456"/> </disks> </action> ---- If you register an entity without specifying the cluster ID or name, the cluster name from the entity's OVF will be used (unless the register request also includes the cluster mapping). This method supports the following parameters: `clone`:: Indicates if the identifiers of the imported virtual machine should be regenerated. By default when a virtual machine is imported the identifiers are preserved. This means that the same virtual machine can't be imported multiple times, as that identifiers needs to be unique. To allow importing the same machine multiple times set this parameter to `true`, as the default is `false`. `collapse_snapshots`:: Indicates of the snapshots of the virtual machine that is imported should be collapsed, so that the result will be a virtual machine without snapshots. This parameter is optional, and if it isn't explicitly specified the default value is `false`. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('clone', clone, bool), ('cluster', cluster, types.Cluster), ('collapse_snapshots', collapse_snapshots, bool), ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ('vm', vm, types.Vm), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, clone=clone, cluster=cluster, collapse_snapshots=collapse_snapshots, exclusive=exclusive, storage_domain=storage_domain, vm=vm, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait) def register( self, allow_partial_import=None, async_=None, clone=None, cluster=None, reassign_bad_macs=None, registration_configuration=None, vm=None, vnic_profile_mappings=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `allow_partial_import`:: Indicates whether a virtual machine is allowed to be registered with only some of its disks. If this flag is `true`, the engine will not fail in the validation process if an image is not found, but instead it will allow the virtual machine to be registered without the missing disks. This is mainly used during registration of a virtual machine when some of the storage domains are not available. The default value is `false`. `vnic_profile_mappings`:: Deprecated attribute describing mapping rules for virtual NIC profiles that will be applied during the import\register process. WARNING: Please note that this attribute has been deprecated since version 4.2.1 of the engine, and preserved only for backward compatibility. It will be removed in the future. To specify `vnic_profile_mappings` use the `vnic_profile_mappings` attribute inside the <<types/registration_configuration, RegistrationConfiguration>> type. `reassign_bad_macs`:: Indicates if the problematic MAC addresses should be re-assigned during the import process by the engine. A MAC address would be considered as a problematic one if one of the following is true: - It conflicts with a MAC address that is already allocated to a virtual machine in the target environment. - It's out of the range of the target MAC address pool. `registration_configuration`:: This parameter describes how the virtual machine should be registered. This parameter is optional. If the parameter is not specified, the virtual machine will be registered with the same configuration that it had in the original environment where it was created. `async_`:: Indicates if the registration should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('allow_partial_import', allow_partial_import, bool), ('async_', async_, bool), ('clone', clone, bool), ('cluster', cluster, types.Cluster), ('reassign_bad_macs', reassign_bad_macs, bool), ('registration_configuration', registration_configuration, types.RegistrationConfiguration), ('vm', vm, types.Vm), ('vnic_profile_mappings', vnic_profile_mappings, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( allow_partial_import=allow_partial_import, async_=async_, clone=clone, cluster=cluster, reassign_bad_macs=reassign_bad_macs, registration_configuration=registration_configuration, vm=vm, vnic_profile_mappings=vnic_profile_mappings, ) # Send the request and wait for the response: return self._internal_action(action, 'register', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Deletes a virtual machine from an export storage domain. For example, to delete the virtual machine `456` from the storage domain `123`, send a request like this: [source] ---- DELETE /ovirt-engine/api/storagedomains/123/vms/456 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def disk_attachments_service(self): """ Returns a reference to the service that manages the disk attachments of the virtual machine. """ return StorageDomainVmDiskAttachmentsService(self._connection, '%s/diskattachments' % self._path) def disks_service(self): """ """ return StorageDomainContentDisksService(self._connection, '%s/disks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'diskattachments': return self.disk_attachments_service() if path.startswith('diskattachments/'): return self.disk_attachments_service().service(path[16:]) if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageDomainVmService:%s' % self._path
View Source
def __init__(self, connection, path): super(StorageDomainVmService, self).__init__(connection, path) self._disk_attachments_service = None self._disks_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
import_(
self,
async_=None,
clone=None,
cluster=None,
collapse_snapshots=None,
exclusive=None,
storage_domain=None,
vm=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def import_( self, async_=None, clone=None, cluster=None, collapse_snapshots=None, exclusive=None, storage_domain=None, vm=None, headers=None, query=None, wait=True, **kwargs ): """ Imports a virtual machine from an export storage domain. For example, send a request like this: [source] ---- POST /ovirt-engine/api/storagedomains/123/vms/456/import ---- With a request body like this: [source,xml] ---- <action> <storage_domain> <name>mydata</name> </storage_domain> <cluster> <name>mycluster</name> </cluster> </action> ---- To import a virtual machine as a new entity add the `clone` parameter: [source,xml] ---- <action> <storage_domain> <name>mydata</name> </storage_domain> <cluster> <name>mycluster</name> </cluster> <clone>true</clone> <vm> <name>myvm</name> </vm> </action> ---- Include an optional `disks` parameter to choose which disks to import. For example, to import the disks of the template that have the identifiers `123` and `456` send the following request body: [source,xml] ---- <action> <cluster> <name>mycluster</name> </cluster> <vm> <name>myvm</name> </vm> <disks> <disk id="123"/> <disk id="456"/> </disks> </action> ---- If you register an entity without specifying the cluster ID or name, the cluster name from the entity's OVF will be used (unless the register request also includes the cluster mapping). This method supports the following parameters: `clone`:: Indicates if the identifiers of the imported virtual machine should be regenerated. By default when a virtual machine is imported the identifiers are preserved. This means that the same virtual machine can't be imported multiple times, as that identifiers needs to be unique. To allow importing the same machine multiple times set this parameter to `true`, as the default is `false`. `collapse_snapshots`:: Indicates of the snapshots of the virtual machine that is imported should be collapsed, so that the result will be a virtual machine without snapshots. This parameter is optional, and if it isn't explicitly specified the default value is `false`. `async_`:: Indicates if the import should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('clone', clone, bool), ('cluster', cluster, types.Cluster), ('collapse_snapshots', collapse_snapshots, bool), ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ('vm', vm, types.Vm), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, clone=clone, cluster=cluster, collapse_snapshots=collapse_snapshots, exclusive=exclusive, storage_domain=storage_domain, vm=vm, ) # Send the request and wait for the response: return self._internal_action(action, 'import', None, headers, query, wait)
Imports a virtual machine from an export storage domain. For example, send a request like this:
[source]
POST /ovirt-engine/api/storagedomains/123/vms/456/import
With a request body like this:
[source,xml]
To import a virtual machine as a new entity add the clone parameter:
[source,xml]
Include an optional disks parameter to choose which disks to import. For example, to import the disks
of the template that have the identifiers 123 and 456 send the following request body:
[source,xml]
If you register an entity without specifying the cluster ID or name, the cluster name from the entity's OVF will be used (unless the register request also includes the cluster mapping).
This method supports the following parameters:
clone:: Indicates if the identifiers of the imported virtual machine
should be regenerated.
By default when a virtual machine is imported the identifiers
are preserved. This means that the same virtual machine can't
be imported multiple times, as that identifiers needs to be
unique. To allow importing the same machine multiple times set
this parameter to true, as the default is false.
collapse_snapshots:: Indicates of the snapshots of the virtual machine that is imported
should be collapsed, so that the result will be a virtual machine
without snapshots.
This parameter is optional, and if it isn't explicitly specified the
default value is false.
async_:: Indicates if the import should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
register(
self,
allow_partial_import=None,
async_=None,
clone=None,
cluster=None,
reassign_bad_macs=None,
registration_configuration=None,
vm=None,
vnic_profile_mappings=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def register( self, allow_partial_import=None, async_=None, clone=None, cluster=None, reassign_bad_macs=None, registration_configuration=None, vm=None, vnic_profile_mappings=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `allow_partial_import`:: Indicates whether a virtual machine is allowed to be registered with only some of its disks. If this flag is `true`, the engine will not fail in the validation process if an image is not found, but instead it will allow the virtual machine to be registered without the missing disks. This is mainly used during registration of a virtual machine when some of the storage domains are not available. The default value is `false`. `vnic_profile_mappings`:: Deprecated attribute describing mapping rules for virtual NIC profiles that will be applied during the import\register process. WARNING: Please note that this attribute has been deprecated since version 4.2.1 of the engine, and preserved only for backward compatibility. It will be removed in the future. To specify `vnic_profile_mappings` use the `vnic_profile_mappings` attribute inside the <<types/registration_configuration, RegistrationConfiguration>> type. `reassign_bad_macs`:: Indicates if the problematic MAC addresses should be re-assigned during the import process by the engine. A MAC address would be considered as a problematic one if one of the following is true: - It conflicts with a MAC address that is already allocated to a virtual machine in the target environment. - It's out of the range of the target MAC address pool. `registration_configuration`:: This parameter describes how the virtual machine should be registered. This parameter is optional. If the parameter is not specified, the virtual machine will be registered with the same configuration that it had in the original environment where it was created. `async_`:: Indicates if the registration should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('allow_partial_import', allow_partial_import, bool), ('async_', async_, bool), ('clone', clone, bool), ('cluster', cluster, types.Cluster), ('reassign_bad_macs', reassign_bad_macs, bool), ('registration_configuration', registration_configuration, types.RegistrationConfiguration), ('vm', vm, types.Vm), ('vnic_profile_mappings', vnic_profile_mappings, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( allow_partial_import=allow_partial_import, async_=async_, clone=clone, cluster=cluster, reassign_bad_macs=reassign_bad_macs, registration_configuration=registration_configuration, vm=vm, vnic_profile_mappings=vnic_profile_mappings, ) # Send the request and wait for the response: return self._internal_action(action, 'register', None, headers, query, wait)
This method supports the following parameters:
allow_partial_import:: Indicates whether a virtual machine is allowed to be registered with only some of its disks.
If this flag is true, the engine will not fail in the validation process if an image is not found, but
instead it will allow the virtual machine to be registered without the missing disks. This is mainly used
during registration of a virtual machine when some of the storage domains are not available. The default
value is false.
vnic_profile_mappings:: Deprecated attribute describing mapping rules for virtual NIC profiles that will be applied during the import
egister process.
WARNING: Please note that this attribute has been deprecated since version 4.2.1 of the engine, and preserved only for backward
compatibility. It will be removed in the future. To specify vnic_profile_mappings use the vnic_profile_mappings
attribute inside the <
reassign_bad_macs:: Indicates if the problematic MAC addresses should be re-assigned during the import process by the engine.
A MAC address would be considered as a problematic one if one of the following is true:
- It conflicts with a MAC address that is already allocated to a virtual machine in the target environment.
- It's out of the range of the target MAC address pool.
registration_configuration:: This parameter describes how the virtual machine should be
registered.
This parameter is optional. If the parameter is not specified, the virtual
machine will be registered with the same configuration that
it had in the original environment where it was created.
async_:: Indicates if the registration should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Deletes a virtual machine from an export storage domain. For example, to delete the virtual machine `456` from the storage domain `123`, send a request like this: [source] ---- DELETE /ovirt-engine/api/storagedomains/123/vms/456 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Deletes a virtual machine from an export storage domain.
For example, to delete the virtual machine 456 from the storage domain 123, send a request like this:
[source]
DELETE /ovirt-engine/api/storagedomains/123/vms/456
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disk_attachments_service(self): """ Returns a reference to the service that manages the disk attachments of the virtual machine. """ return StorageDomainVmDiskAttachmentsService(self._connection, '%s/diskattachments' % self._path)
Returns a reference to the service that manages the disk attachments of the virtual machine.
View Source
def disks_service(self): """ """ return StorageDomainContentDisksService(self._connection, '%s/disks' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'diskattachments': return self.disk_attachments_service() if path.startswith('diskattachments/'): return self.disk_attachments_service().service(path[16:]) if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageDomainVmDiskAttachmentService(Service): """ Returns the details of the disks attached to a virtual machine in the export domain. """ def __init__(self, connection, path): super(StorageDomainVmDiskAttachmentService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the details of the attachment with all its properties and a link to the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageDomainVmDiskAttachmentService:%s' % self._path
Returns the details of the disks attached to a virtual machine in the export domain.
View Source
def __init__(self, connection, path): super(StorageDomainVmDiskAttachmentService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the details of the attachment with all its properties and a link to the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the details of the attachment with all its properties and a link to the disk.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageDomainVmDiskAttachmentsService(Service): """ Returns the details of a disk attached to a virtual machine in the export domain. """ def __init__(self, connection, path): super(StorageDomainVmDiskAttachmentsService, self).__init__(connection, path) self._attachment_service = None def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List the disks that are attached to the virtual machine. The order of the returned list of disk attachments isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def attachment_service(self, id): """ Reference to the service that manages a specific attachment. """ Service._check_types([ ('id', id, str), ]) return StorageDomainVmDiskAttachmentService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.attachment_service(path) return self.attachment_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageDomainVmDiskAttachmentsService:%s' % self._path
Returns the details of a disk attached to a virtual machine in the export domain.
View Source
def __init__(self, connection, path): super(StorageDomainVmDiskAttachmentsService, self).__init__(connection, path) self._attachment_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List the disks that are attached to the virtual machine. The order of the returned list of disk attachments isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List the disks that are attached to the virtual machine. The order of the returned list of disk attachments isn't guaranteed.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def attachment_service(self, id): """ Reference to the service that manages a specific attachment. """ Service._check_types([ ('id', id, str), ]) return StorageDomainVmDiskAttachmentService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages a specific attachment.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.attachment_service(path) return self.attachment_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageDomainVmsService(Service): """ Lists the virtual machines of an export storage domain. For example, to retrieve the virtual machines that are available in the storage domain with identifier `123` send the following request: [source] ---- GET /ovirt-engine/api/storagedomains/123/vms ---- This will return the following response body: [source,xml] ---- <vms> <vm id="456" href="/api/storagedomains/123/vms/456"> <name>vm1</name> ... <storage_domain id="123" href="/api/storagedomains/123"/> <actions> <link rel="import" href="/api/storagedomains/123/vms/456/import"/> </actions> </vm> </vms> ---- Virtual machines and templates in these collections have a similar representation to their counterparts in the top-level <<types/vm, Vm>> and <<types/template, Template>> collections, except they also contain a <<types/storage_domain, StorageDomain>> reference and an <<services/storage_domain_vm/methods/import, import>> action. """ def __init__(self, connection, path): super(StorageDomainVmsService, self).__init__(connection, path) self._vm_service = None def list( self, follow=None, max=None, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of virtual machines of the export storage domain. The order of the returned list of virtual machines isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of virtual machines to return. If not specified all the virtual machines are returned. `unregistered`:: Indicates whether to retrieve a list of registered or unregistered virtual machines which contain disks on the storage domain. To get a list of unregistered virtual machines the call should indicate the unregistered flag. For example, to get a list of unregistered virtual machines the REST API call should look like this: .... GET /ovirt-engine/api/storagedomains/123/vms?unregistered=true .... The default value of the unregisterd flag is `false`. The request only apply to storage domains that are attached. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_get(headers, query, wait) def vm_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainVmService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.vm_service(path) return self.vm_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageDomainVmsService:%s' % self._path
Lists the virtual machines of an export storage domain.
For example, to retrieve the virtual machines that are available in the storage domain with identifier 123 send the
following request:
[source]
GET /ovirt-engine/api/storagedomains/123/vms
This will return the following response body:
[source,xml]
Virtual machines and templates in these collections have a similar representation to their counterparts in the
top-level <
View Source
def __init__(self, connection, path): super(StorageDomainVmsService, self).__init__(connection, path) self._vm_service = None
Creates a new service that will use the given connection and path.
#
def
list(
self,
follow=None,
max=None,
unregistered=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, follow=None, max=None, unregistered=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of virtual machines of the export storage domain. The order of the returned list of virtual machines isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of virtual machines to return. If not specified all the virtual machines are returned. `unregistered`:: Indicates whether to retrieve a list of registered or unregistered virtual machines which contain disks on the storage domain. To get a list of unregistered virtual machines the call should indicate the unregistered flag. For example, to get a list of unregistered virtual machines the REST API call should look like this: .... GET /ovirt-engine/api/storagedomains/123/vms?unregistered=true .... The default value of the unregisterd flag is `false`. The request only apply to storage domains that are attached. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ('unregistered', unregistered, bool), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if unregistered is not None: unregistered = Writer.render_boolean(unregistered) query['unregistered'] = unregistered # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of virtual machines of the export storage domain. The order of the returned list of virtual machines isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of virtual machines to return. If not specified all the virtual machines are
returned.
unregistered:: Indicates whether to retrieve a list of registered or unregistered virtual machines which
contain disks on the storage domain.
To get a list of unregistered virtual machines the call should indicate the unregistered flag.
For example, to get a list of unregistered virtual machines the REST API call should look like this:
....
GET /ovirt-engine/api/storagedomains/123/vms?unregistered=true
....
The default value of the unregisterd flag is false.
The request only apply to storage domains that are attached.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def vm_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainVmService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.vm_service(path) return self.vm_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageDomainsService(Service): """ Manages the set of storage domains in the system. """ def __init__(self, connection, path): super(StorageDomainsService, self).__init__(connection, path) self._storage_domain_service = None def add( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Adds a new storage domain. Creation of a new <<types/storage_domain,StorageDomain>> requires the `name`, `type`, `host`, and `storage` attributes. Identify the `host` attribute with the `id` or `name` attributes. In {product-name} 3.6 and later you can enable the wipe after delete option by default on the storage domain. To configure this, specify `wipe_after_delete` in the POST request. This option can be edited after the domain is created, but doing so will not change the wipe after delete property of disks that already exist. To add a new storage domain with specified `name`, `type`, `storage.type`, `storage.address`, and `storage.path`, and using a host with an id `123`, send a request like this: [source] ---- POST /ovirt-engine/api/storageDomains ---- With a request body like this: [source,xml] ---- <storage_domain> <name>mydata</name> <type>data</type> <storage> <type>nfs</type> <address>mynfs.example.com</address> <path>/exports/mydata</path> </storage> <host> <name>myhost</name> </host> </storage_domain> ---- To create a new NFS ISO storage domain send a request like this: [source,xml] ---- <storage_domain> <name>myisos</name> <type>iso</type> <storage> <type>nfs</type> <address>mynfs.example.com</address> <path>/export/myisos</path> </storage> <host> <name>myhost</name> </host> </storage_domain> ---- To create a new iSCSI storage domain send a request like this: [source,xml] ---- <storage_domain> <name>myiscsi</name> <type>data</type> <storage> <type>iscsi</type> <logical_units> <logical_unit id="3600144f09dbd050000004eedbd340001"/> <logical_unit id="3600144f09dbd050000004eedbd340002"/> </logical_units> </storage> <host> <name>myhost</name> </host> </storage_domain> ---- This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait) def add_block_domain( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Import an existing block storage domain to the system using the targets already connected to the host. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait) def add_by_path( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Add a new storage domain to the system using the storage on the given host and path. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait) def add_direct_lun( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Add a new storage domain to the system using a direct LUN. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait) def add_gluster_or_postfs( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Add a new storage domain to the system using Gluster or POSIX FS storage. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait) def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of storage domains in the system. The order of the returned list of storage domains is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of storage domains to return. If not specified, all the storage domains are returned. `search`:: A query string used to restrict the returned storage domains. `case_sensitive`:: Indicates if the search should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case, set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def add_local( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Add a new storage domain to the system using the storage on the local host at the given path. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait) def storage_domain_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_domain_service(path) return self.storage_domain_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageDomainsService:%s' % self._path
Manages the set of storage domains in the system.
View Source
def __init__(self, connection, path): super(StorageDomainsService, self).__init__(connection, path) self._storage_domain_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Adds a new storage domain. Creation of a new <<types/storage_domain,StorageDomain>> requires the `name`, `type`, `host`, and `storage` attributes. Identify the `host` attribute with the `id` or `name` attributes. In {product-name} 3.6 and later you can enable the wipe after delete option by default on the storage domain. To configure this, specify `wipe_after_delete` in the POST request. This option can be edited after the domain is created, but doing so will not change the wipe after delete property of disks that already exist. To add a new storage domain with specified `name`, `type`, `storage.type`, `storage.address`, and `storage.path`, and using a host with an id `123`, send a request like this: [source] ---- POST /ovirt-engine/api/storageDomains ---- With a request body like this: [source,xml] ---- <storage_domain> <name>mydata</name> <type>data</type> <storage> <type>nfs</type> <address>mynfs.example.com</address> <path>/exports/mydata</path> </storage> <host> <name>myhost</name> </host> </storage_domain> ---- To create a new NFS ISO storage domain send a request like this: [source,xml] ---- <storage_domain> <name>myisos</name> <type>iso</type> <storage> <type>nfs</type> <address>mynfs.example.com</address> <path>/export/myisos</path> </storage> <host> <name>myhost</name> </host> </storage_domain> ---- To create a new iSCSI storage domain send a request like this: [source,xml] ---- <storage_domain> <name>myiscsi</name> <type>data</type> <storage> <type>iscsi</type> <logical_units> <logical_unit id="3600144f09dbd050000004eedbd340001"/> <logical_unit id="3600144f09dbd050000004eedbd340002"/> </logical_units> </storage> <host> <name>myhost</name> </host> </storage_domain> ---- This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait)
Adds a new storage domain.
Creation of a new <name, type, host, and storage
attributes. Identify the host attribute with the id or name attributes. In {product-name} 3.6 and
later you can enable the wipe after delete option by default on the storage domain. To configure this, specify
wipe_after_delete in the POST request. This option can be edited after the domain is created, but doing so will
not change the wipe after delete property of disks that already exist.
To add a new storage domain with specified name, type, storage.type, storage.address, and storage.path,
and using a host with an id 123, send a request like this:
[source]
POST /ovirt-engine/api/storageDomains
With a request body like this:
[source,xml]
To create a new NFS ISO storage domain send a request like this:
[source,xml]
To create a new iSCSI storage domain send a request like this:
[source,xml]
This method supports the following parameters:
storage_domain:: The storage domain to add.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_block_domain( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Import an existing block storage domain to the system using the targets already connected to the host. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait)
Import an existing block storage domain to the system using the targets already connected to the host.
This method supports the following parameters:
storage_domain:: The storage domain to add.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_by_path( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Add a new storage domain to the system using the storage on the given host and path. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait)
Add a new storage domain to the system using the storage on the given host and path.
This method supports the following parameters:
storage_domain:: The storage domain to add.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_direct_lun( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Add a new storage domain to the system using a direct LUN. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait)
Add a new storage domain to the system using a direct LUN.
This method supports the following parameters:
storage_domain:: The storage domain to add.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_gluster_or_postfs( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Add a new storage domain to the system using Gluster or POSIX FS storage. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait)
Add a new storage domain to the system using Gluster or POSIX FS storage.
This method supports the following parameters:
storage_domain:: The storage domain to add.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
list(
self,
case_sensitive=None,
filter=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of storage domains in the system. The order of the returned list of storage domains is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of storage domains to return. If not specified, all the storage domains are returned. `search`:: A query string used to restrict the returned storage domains. `case_sensitive`:: Indicates if the search should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case, set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of storage domains in the system.
The order of the returned list of storage domains is guaranteed only if the sortby clause is included
in the search parameter.
This method supports the following parameters:
max:: Sets the maximum number of storage domains to return. If not specified, all the storage domains are returned.
search:: A query string used to restrict the returned storage domains.
case_sensitive:: Indicates if the search should be performed taking case into account.
The default value is true, which means that case is taken into account. If you want to search
ignoring case, set it to false.
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_local( self, storage_domain, headers=None, query=None, wait=True, **kwargs ): """ Add a new storage domain to the system using the storage on the local host at the given path. This method supports the following parameters: `storage_domain`:: The storage domain to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(storage_domain, headers, query, wait)
Add a new storage domain to the system using the storage on the local host at the given path.
This method supports the following parameters:
storage_domain:: The storage domain to add.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def storage_domain_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageDomainService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_domain_service(path) return self.storage_domain_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageServerConnectionService(Service): """ """ def __init__(self, connection, path): super(StorageServerConnectionService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def update_glusterfs( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified Glusterfs storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait) def update_iscsi( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified iSCSI storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait) def update_local( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified local storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait) def update_nfs( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified NFS storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait) def remove( self, host=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a storage connection. A storage connection can only be deleted if neither storage domain nor LUN disks reference it. The host name or id is optional; providing it disconnects (unmounts) the connection from that host. This method supports the following parameters: `host`:: The name or identifier of the host from which the connection would be unmounted (disconnected). If not provided, no host will be disconnected. For example, to use the host with identifier `456` to delete the storage connection with identifier `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/storageconnections/123?host=456 ---- `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, str), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if host is not None: query['host'] = host if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the storage connection. For example, to change the address of an NFS storage server, send a request like this: [source,xml] ---- PUT /ovirt-engine/api/storageconnections/123 ---- With a request body like this: [source,xml] ---- <storage_connection> <address>mynewnfs.example.com</address> </storage_connection> ---- To change the connection of an iSCSI storage server, send a request like this: [source,xml] ---- PUT /ovirt-engine/api/storageconnections/123 ---- With a request body like this: [source,xml] ---- <storage_connection> <port>3260</port> <target>iqn.2017-01.com.myhost:444</target> </storage_connection> ---- """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait) def update_vfs( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified VFS storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageServerConnectionService:%s' % self._path
View Source
def __init__(self, connection, path): super(StorageServerConnectionService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
update_glusterfs(
self,
connection,
async_=None,
force=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def update_glusterfs( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified Glusterfs storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait)
Update the specified Glusterfs storage connection in the system.
#
def
update_iscsi(
self,
connection,
async_=None,
force=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def update_iscsi( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified iSCSI storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait)
Update the specified iSCSI storage connection in the system.
#
def
update_local(
self,
connection,
async_=None,
force=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def update_local( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified local storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait)
Update the specified local storage connection in the system.
#
def
update_nfs(
self,
connection,
async_=None,
force=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def update_nfs( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified NFS storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait)
Update the specified NFS storage connection in the system.
View Source
def remove( self, host=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a storage connection. A storage connection can only be deleted if neither storage domain nor LUN disks reference it. The host name or id is optional; providing it disconnects (unmounts) the connection from that host. This method supports the following parameters: `host`:: The name or identifier of the host from which the connection would be unmounted (disconnected). If not provided, no host will be disconnected. For example, to use the host with identifier `456` to delete the storage connection with identifier `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/storageconnections/123?host=456 ---- `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, str), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if host is not None: query['host'] = host if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes a storage connection. A storage connection can only be deleted if neither storage domain nor LUN disks reference it. The host name or id is optional; providing it disconnects (unmounts) the connection from that host.
This method supports the following parameters:
host:: The name or identifier of the host from which the connection would be unmounted (disconnected). If not
provided, no host will be disconnected.
For example, to use the host with identifier 456 to delete the storage connection with identifier 123
send a request like this:
[source]
DELETE /ovirt-engine/api/storageconnections/123?host=456
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
update(
self,
connection,
async_=None,
force=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def update( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the storage connection. For example, to change the address of an NFS storage server, send a request like this: [source,xml] ---- PUT /ovirt-engine/api/storageconnections/123 ---- With a request body like this: [source,xml] ---- <storage_connection> <address>mynewnfs.example.com</address> </storage_connection> ---- To change the connection of an iSCSI storage server, send a request like this: [source,xml] ---- PUT /ovirt-engine/api/storageconnections/123 ---- With a request body like this: [source,xml] ---- <storage_connection> <port>3260</port> <target>iqn.2017-01.com.myhost:444</target> </storage_connection> ---- """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait)
Updates the storage connection. For example, to change the address of an NFS storage server, send a request like this:
[source,xml]
PUT /ovirt-engine/api/storageconnections/123
With a request body like this:
[source,xml]
To change the connection of an iSCSI storage server, send a request like this:
[source,xml]
PUT /ovirt-engine/api/storageconnections/123
With a request body like this:
[source,xml]
#
def
update_vfs(
self,
connection,
async_=None,
force=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def update_vfs( self, connection, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified VFS storage connection in the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: return self._internal_update(connection, headers, query, wait)
Update the specified VFS storage connection in the system.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageServerConnectionExtensionService(Service): """ """ def __init__(self, connection, path): super(StorageServerConnectionExtensionService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, extension, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update a storage server connection extension for the given host. To update the storage connection `456` of host `123` send a request like this: [source] ---- PUT /ovirt-engine/api/hosts/123/storageconnectionextensions/456 ---- With a request body like this: [source,xml] ---- <storage_connection_extension> <target>iqn.2016-01.com.example:mytarget</target> <username>myuser</username> <password>mypassword</password> </storage_connection_extension> ---- """ # Check the types of the parameters: Service._check_types([ ('extension', extension, types.StorageConnectionExtension), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(extension, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'StorageServerConnectionExtensionService:%s' % self._path
View Source
def __init__(self, connection, path): super(StorageServerConnectionExtensionService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, extension, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update a storage server connection extension for the given host. To update the storage connection `456` of host `123` send a request like this: [source] ---- PUT /ovirt-engine/api/hosts/123/storageconnectionextensions/456 ---- With a request body like this: [source,xml] ---- <storage_connection_extension> <target>iqn.2016-01.com.example:mytarget</target> <username>myuser</username> <password>mypassword</password> </storage_connection_extension> ---- """ # Check the types of the parameters: Service._check_types([ ('extension', extension, types.StorageConnectionExtension), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(extension, headers, query, wait)
Update a storage server connection extension for the given host.
To update the storage connection 456 of host 123 send a request like this:
[source]
PUT /ovirt-engine/api/hosts/123/storageconnectionextensions/456
With a request body like this:
[source,xml]
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageServerConnectionExtensionsService(Service): """ """ def __init__(self, connection, path): super(StorageServerConnectionExtensionsService, self).__init__(connection, path) self._storage_connection_extension_service = None def add( self, extension, headers=None, query=None, wait=True, **kwargs ): """ Creates a new storage server connection extension for the given host. The extension lets the user define credentials for an iSCSI target for a specific host. For example to use `myuser` and `mypassword` as the credentials when connecting to the iSCSI target from host `123` send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/storageconnectionextensions ---- With a request body like this: [source,xml] ---- <storage_connection_extension> <target>iqn.2016-01.com.example:mytarget</target> <username>myuser</username> <password>mypassword</password> </storage_connection_extension> ---- """ # Check the types of the parameters: Service._check_types([ ('extension', extension, types.StorageConnectionExtension), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(extension, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list os storage connection extensions. The order of the returned list of storage connections isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of extensions to return. If not specified all the extensions are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def storage_connection_extension_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageServerConnectionExtensionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_connection_extension_service(path) return self.storage_connection_extension_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageServerConnectionExtensionsService:%s' % self._path
View Source
def __init__(self, connection, path): super(StorageServerConnectionExtensionsService, self).__init__(connection, path) self._storage_connection_extension_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, extension, headers=None, query=None, wait=True, **kwargs ): """ Creates a new storage server connection extension for the given host. The extension lets the user define credentials for an iSCSI target for a specific host. For example to use `myuser` and `mypassword` as the credentials when connecting to the iSCSI target from host `123` send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/storageconnectionextensions ---- With a request body like this: [source,xml] ---- <storage_connection_extension> <target>iqn.2016-01.com.example:mytarget</target> <username>myuser</username> <password>mypassword</password> </storage_connection_extension> ---- """ # Check the types of the parameters: Service._check_types([ ('extension', extension, types.StorageConnectionExtension), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(extension, headers, query, wait)
Creates a new storage server connection extension for the given host.
The extension lets the user define credentials for an iSCSI target for a specific host. For example to use
myuser and mypassword as the credentials when connecting to the iSCSI target from host 123 send a request
like this:
[source]
POST /ovirt-engine/api/hosts/123/storageconnectionextensions
With a request body like this:
[source,xml]
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list os storage connection extensions. The order of the returned list of storage connections isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of extensions to return. If not specified all the extensions are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list os storage connection extensions. The order of the returned list of storage connections isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of extensions to return. If not specified all the extensions are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def storage_connection_extension_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageServerConnectionExtensionService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_connection_extension_service(path) return self.storage_connection_extension_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class StorageServerConnectionsService(Service): """ """ def __init__(self, connection, path): super(StorageServerConnectionsService, self).__init__(connection, path) self._storage_connection_service = None def add( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Creates a new storage connection. For example, to create a new storage connection for the NFS server `mynfs.example.com` and NFS share `/export/mydata` send a request like this: [source] ---- POST /ovirt-engine/api/storageconnections ---- With a request body like this: [source,xml] ---- <storage_connection> <type>nfs</type> <address>mynfs.example.com</address> <path>/export/mydata</path> <host> <name>myhost</name> </host> </storage_connection> ---- """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait) def add_glusterfs( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a Glusterfs storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait) def add_iscsi( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a iSCSI storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of storage connections. The order of the returned list of connections isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of connections to return. If not specified all the connections are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def add_local( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a local storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait) def add_nfs( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a nfs storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait) def add_vfs( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a vfs storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait) def storage_connection_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageServerConnectionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_connection_service(path) return self.storage_connection_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'StorageServerConnectionsService:%s' % self._path
View Source
def __init__(self, connection, path): super(StorageServerConnectionsService, self).__init__(connection, path) self._storage_connection_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Creates a new storage connection. For example, to create a new storage connection for the NFS server `mynfs.example.com` and NFS share `/export/mydata` send a request like this: [source] ---- POST /ovirt-engine/api/storageconnections ---- With a request body like this: [source,xml] ---- <storage_connection> <type>nfs</type> <address>mynfs.example.com</address> <path>/export/mydata</path> <host> <name>myhost</name> </host> </storage_connection> ---- """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait)
Creates a new storage connection.
For example, to create a new storage connection for the NFS server mynfs.example.com and NFS share
/export/mydata send a request like this:
[source]
POST /ovirt-engine/api/storageconnections
With a request body like this:
[source,xml]
View Source
def add_glusterfs( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a Glusterfs storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait)
Add a Glusterfs storage connection to the system.
View Source
def add_iscsi( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a iSCSI storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait)
Add a iSCSI storage connection to the system.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of storage connections. The order of the returned list of connections isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of connections to return. If not specified all the connections are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of storage connections. The order of the returned list of connections isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of connections to return. If not specified all the connections are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_local( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a local storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait)
Add a local storage connection to the system.
View Source
def add_nfs( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a nfs storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait)
Add a nfs storage connection to the system.
View Source
def add_vfs( self, connection, headers=None, query=None, wait=True, **kwargs ): """ Add a vfs storage connection to the system. """ # Check the types of the parameters: Service._check_types([ ('connection', connection, types.StorageConnection), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(connection, headers, query, wait)
Add a vfs storage connection to the system.
View Source
def storage_connection_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return StorageServerConnectionService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.storage_connection_service(path) return self.storage_connection_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SystemService(Service): """ """ def __init__(self, connection, path): super(SystemService, self).__init__(connection, path) self._affinity_labels_service = None self._bookmarks_service = None self._cluster_levels_service = None self._clusters_service = None self._cpu_profiles_service = None self._data_centers_service = None self._disk_profiles_service = None self._disks_service = None self._domains_service = None self._events_service = None self._external_host_providers_service = None self._external_template_imports_service = None self._external_vm_imports_service = None self._groups_service = None self._hosts_service = None self._icons_service = None self._image_transfers_service = None self._instance_types_service = None self._jobs_service = None self._katello_errata_service = None self._mac_pools_service = None self._network_filters_service = None self._networks_service = None self._openstack_image_providers_service = None self._openstack_network_providers_service = None self._openstack_volume_providers_service = None self._operating_systems_service = None self._options_service = None self._permissions_service = None self._roles_service = None self._scheduling_policies_service = None self._scheduling_policy_units_service = None self._storage_connections_service = None self._storage_domains_service = None self._tags_service = None self._templates_service = None self._users_service = None self._vm_pools_service = None self._vms_service = None self._vnic_profiles_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns basic information describing the API, like the product name, the version number and a summary of the number of relevant objects. [source] ---- GET /ovirt-engine/api ---- We get following response: [source,xml] ---- <api> <link rel="capabilities" href="/api/capabilities"/> <link rel="clusters" href="/api/clusters"/> <link rel="clusters/search" href="/api/clusters?search={query}"/> <link rel="datacenters" href="/api/datacenters"/> <link rel="datacenters/search" href="/api/datacenters?search={query}"/> <link rel="events" href="/api/events"/> <link rel="events/search" href="/api/events?search={query}"/> <link rel="hosts" href="/api/hosts"/> <link rel="hosts/search" href="/api/hosts?search={query}"/> <link rel="networks" href="/api/networks"/> <link rel="roles" href="/api/roles"/> <link rel="storagedomains" href="/api/storagedomains"/> <link rel="storagedomains/search" href="/api/storagedomains?search={query}"/> <link rel="tags" href="/api/tags"/> <link rel="templates" href="/api/templates"/> <link rel="templates/search" href="/api/templates?search={query}"/> <link rel="users" href="/api/users"/> <link rel="groups" href="/api/groups"/> <link rel="domains" href="/api/domains"/> <link rel="vmpools" href="/api/vmpools"/> <link rel="vmpools/search" href="/api/vmpools?search={query}"/> <link rel="vms" href="/api/vms"/> <link rel="vms/search" href="/api/vms?search={query}"/> <product_info> <name>oVirt Engine</name> <vendor>ovirt.org</vendor> <version> <build>4</build> <full_version>4.0.4</full_version> <major>4</major> <minor>0</minor> <revision>0</revision> </version> </product_info> <special_objects> <blank_template href="/ovirt-engine/api/templates/00000000-0000-0000-0000-000000000000" id="00000000-0000-0000-0000-000000000000"/> <root_tag href="/ovirt-engine/api/tags/00000000-0000-0000-0000-000000000000" id="00000000-0000-0000-0000-000000000000"/> </special_objects> <summary> <hosts> <active>0</active> <total>0</total> </hosts> <storage_domains> <active>0</active> <total>1</total> </storage_domains> <users> <active>1</active> <total>1</total> </users> <vms> <active>0</active> <total>0</total> </vms> </summary> <time>2016-09-14T12:00:48.132+02:00</time> </api> ---- The entry point provides a user with links to the collections in a virtualization environment. The `rel` attribute of each collection link provides a reference point for each link. The entry point also contains other data such as `product_info`, `special_objects` and `summary`. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def reload_configurations( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the reload should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reloadconfigurations', None, headers, query, wait) def affinity_labels_service(self): """ List all known affinity labels. """ return AffinityLabelsService(self._connection, '%s/affinitylabels' % self._path) def bookmarks_service(self): """ """ return BookmarksService(self._connection, '%s/bookmarks' % self._path) def cluster_levels_service(self): """ Reference to the service that provides information about the cluster levels supported by the system. """ return ClusterLevelsService(self._connection, '%s/clusterlevels' % self._path) def clusters_service(self): """ """ return ClustersService(self._connection, '%s/clusters' % self._path) def cpu_profiles_service(self): """ """ return CpuProfilesService(self._connection, '%s/cpuprofiles' % self._path) def data_centers_service(self): """ """ return DataCentersService(self._connection, '%s/datacenters' % self._path) def disk_profiles_service(self): """ """ return DiskProfilesService(self._connection, '%s/diskprofiles' % self._path) def disks_service(self): """ """ return DisksService(self._connection, '%s/disks' % self._path) def domains_service(self): """ """ return DomainsService(self._connection, '%s/domains' % self._path) def events_service(self): """ """ return EventsService(self._connection, '%s/events' % self._path) def external_host_providers_service(self): """ """ return ExternalHostProvidersService(self._connection, '%s/externalhostproviders' % self._path) def external_template_imports_service(self): """ Reference to service facilitating import of external templates. """ return ExternalTemplateImportsService(self._connection, '%s/externaltemplateimports' % self._path) def external_vm_imports_service(self): """ Reference to service facilitating import of external virtual machines. """ return ExternalVmImportsService(self._connection, '%s/externalvmimports' % self._path) def groups_service(self): """ """ return GroupsService(self._connection, '%s/groups' % self._path) def hosts_service(self): """ """ return HostsService(self._connection, '%s/hosts' % self._path) def icons_service(self): """ """ return IconsService(self._connection, '%s/icons' % self._path) def image_transfers_service(self): """ List of all image transfers being performed for image I/O in oVirt. """ return ImageTransfersService(self._connection, '%s/imagetransfers' % self._path) def instance_types_service(self): """ """ return InstanceTypesService(self._connection, '%s/instancetypes' % self._path) def jobs_service(self): """ List all the jobs monitored by the engine. """ return JobsService(self._connection, '%s/jobs' % self._path) def katello_errata_service(self): """ List the available Katello errata assigned to the engine. """ return EngineKatelloErrataService(self._connection, '%s/katelloerrata' % self._path) def mac_pools_service(self): """ """ return MacPoolsService(self._connection, '%s/macpools' % self._path) def network_filters_service(self): """ Network filters will enhance the admin ability to manage the network packets traffic from/to the participated VMs. """ return NetworkFiltersService(self._connection, '%s/networkfilters' % self._path) def networks_service(self): """ """ return NetworksService(self._connection, '%s/networks' % self._path) def openstack_image_providers_service(self): """ """ return OpenstackImageProvidersService(self._connection, '%s/openstackimageproviders' % self._path) def openstack_network_providers_service(self): """ """ return OpenstackNetworkProvidersService(self._connection, '%s/openstacknetworkproviders' % self._path) def openstack_volume_providers_service(self): """ """ return OpenstackVolumeProvidersService(self._connection, '%s/openstackvolumeproviders' % self._path) def operating_systems_service(self): """ """ return OperatingSystemsService(self._connection, '%s/operatingsystems' % self._path) def options_service(self): """ Reference to the service that provides values of configuration options of the system. """ return SystemOptionsService(self._connection, '%s/options' % self._path) def permissions_service(self): """ """ return SystemPermissionsService(self._connection, '%s/permissions' % self._path) def roles_service(self): """ """ return RolesService(self._connection, '%s/roles' % self._path) def scheduling_policies_service(self): """ """ return SchedulingPoliciesService(self._connection, '%s/schedulingpolicies' % self._path) def scheduling_policy_units_service(self): """ """ return SchedulingPolicyUnitsService(self._connection, '%s/schedulingpolicyunits' % self._path) def storage_connections_service(self): """ """ return StorageServerConnectionsService(self._connection, '%s/storageconnections' % self._path) def storage_domains_service(self): """ """ return StorageDomainsService(self._connection, '%s/storagedomains' % self._path) def tags_service(self): """ """ return TagsService(self._connection, '%s/tags' % self._path) def templates_service(self): """ """ return TemplatesService(self._connection, '%s/templates' % self._path) def users_service(self): """ """ return UsersService(self._connection, '%s/users' % self._path) def vm_pools_service(self): """ """ return VmPoolsService(self._connection, '%s/vmpools' % self._path) def vms_service(self): """ """ return VmsService(self._connection, '%s/vms' % self._path) def vnic_profiles_service(self): """ """ return VnicProfilesService(self._connection, '%s/vnicprofiles' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'affinitylabels': return self.affinity_labels_service() if path.startswith('affinitylabels/'): return self.affinity_labels_service().service(path[15:]) if path == 'bookmarks': return self.bookmarks_service() if path.startswith('bookmarks/'): return self.bookmarks_service().service(path[10:]) if path == 'clusterlevels': return self.cluster_levels_service() if path.startswith('clusterlevels/'): return self.cluster_levels_service().service(path[14:]) if path == 'clusters': return self.clusters_service() if path.startswith('clusters/'): return self.clusters_service().service(path[9:]) if path == 'cpuprofiles': return self.cpu_profiles_service() if path.startswith('cpuprofiles/'): return self.cpu_profiles_service().service(path[12:]) if path == 'datacenters': return self.data_centers_service() if path.startswith('datacenters/'): return self.data_centers_service().service(path[12:]) if path == 'diskprofiles': return self.disk_profiles_service() if path.startswith('diskprofiles/'): return self.disk_profiles_service().service(path[13:]) if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) if path == 'domains': return self.domains_service() if path.startswith('domains/'): return self.domains_service().service(path[8:]) if path == 'events': return self.events_service() if path.startswith('events/'): return self.events_service().service(path[7:]) if path == 'externalhostproviders': return self.external_host_providers_service() if path.startswith('externalhostproviders/'): return self.external_host_providers_service().service(path[22:]) if path == 'externaltemplateimports': return self.external_template_imports_service() if path.startswith('externaltemplateimports/'): return self.external_template_imports_service().service(path[24:]) if path == 'externalvmimports': return self.external_vm_imports_service() if path.startswith('externalvmimports/'): return self.external_vm_imports_service().service(path[18:]) if path == 'groups': return self.groups_service() if path.startswith('groups/'): return self.groups_service().service(path[7:]) if path == 'hosts': return self.hosts_service() if path.startswith('hosts/'): return self.hosts_service().service(path[6:]) if path == 'icons': return self.icons_service() if path.startswith('icons/'): return self.icons_service().service(path[6:]) if path == 'imagetransfers': return self.image_transfers_service() if path.startswith('imagetransfers/'): return self.image_transfers_service().service(path[15:]) if path == 'instancetypes': return self.instance_types_service() if path.startswith('instancetypes/'): return self.instance_types_service().service(path[14:]) if path == 'jobs': return self.jobs_service() if path.startswith('jobs/'): return self.jobs_service().service(path[5:]) if path == 'katelloerrata': return self.katello_errata_service() if path.startswith('katelloerrata/'): return self.katello_errata_service().service(path[14:]) if path == 'macpools': return self.mac_pools_service() if path.startswith('macpools/'): return self.mac_pools_service().service(path[9:]) if path == 'networkfilters': return self.network_filters_service() if path.startswith('networkfilters/'): return self.network_filters_service().service(path[15:]) if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) if path == 'openstackimageproviders': return self.openstack_image_providers_service() if path.startswith('openstackimageproviders/'): return self.openstack_image_providers_service().service(path[24:]) if path == 'openstacknetworkproviders': return self.openstack_network_providers_service() if path.startswith('openstacknetworkproviders/'): return self.openstack_network_providers_service().service(path[26:]) if path == 'openstackvolumeproviders': return self.openstack_volume_providers_service() if path.startswith('openstackvolumeproviders/'): return self.openstack_volume_providers_service().service(path[25:]) if path == 'operatingsystems': return self.operating_systems_service() if path.startswith('operatingsystems/'): return self.operating_systems_service().service(path[17:]) if path == 'options': return self.options_service() if path.startswith('options/'): return self.options_service().service(path[8:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'roles': return self.roles_service() if path.startswith('roles/'): return self.roles_service().service(path[6:]) if path == 'schedulingpolicies': return self.scheduling_policies_service() if path.startswith('schedulingpolicies/'): return self.scheduling_policies_service().service(path[19:]) if path == 'schedulingpolicyunits': return self.scheduling_policy_units_service() if path.startswith('schedulingpolicyunits/'): return self.scheduling_policy_units_service().service(path[22:]) if path == 'storageconnections': return self.storage_connections_service() if path.startswith('storageconnections/'): return self.storage_connections_service().service(path[19:]) if path == 'storagedomains': return self.storage_domains_service() if path.startswith('storagedomains/'): return self.storage_domains_service().service(path[15:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) if path == 'templates': return self.templates_service() if path.startswith('templates/'): return self.templates_service().service(path[10:]) if path == 'users': return self.users_service() if path.startswith('users/'): return self.users_service().service(path[6:]) if path == 'vmpools': return self.vm_pools_service() if path.startswith('vmpools/'): return self.vm_pools_service().service(path[8:]) if path == 'vms': return self.vms_service() if path.startswith('vms/'): return self.vms_service().service(path[4:]) if path == 'vnicprofiles': return self.vnic_profiles_service() if path.startswith('vnicprofiles/'): return self.vnic_profiles_service().service(path[13:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SystemService:%s' % self._path
View Source
def __init__(self, connection, path): super(SystemService, self).__init__(connection, path) self._affinity_labels_service = None self._bookmarks_service = None self._cluster_levels_service = None self._clusters_service = None self._cpu_profiles_service = None self._data_centers_service = None self._disk_profiles_service = None self._disks_service = None self._domains_service = None self._events_service = None self._external_host_providers_service = None self._external_template_imports_service = None self._external_vm_imports_service = None self._groups_service = None self._hosts_service = None self._icons_service = None self._image_transfers_service = None self._instance_types_service = None self._jobs_service = None self._katello_errata_service = None self._mac_pools_service = None self._network_filters_service = None self._networks_service = None self._openstack_image_providers_service = None self._openstack_network_providers_service = None self._openstack_volume_providers_service = None self._operating_systems_service = None self._options_service = None self._permissions_service = None self._roles_service = None self._scheduling_policies_service = None self._scheduling_policy_units_service = None self._storage_connections_service = None self._storage_domains_service = None self._tags_service = None self._templates_service = None self._users_service = None self._vm_pools_service = None self._vms_service = None self._vnic_profiles_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns basic information describing the API, like the product name, the version number and a summary of the number of relevant objects. [source] ---- GET /ovirt-engine/api ---- We get following response: [source,xml] ---- <api> <link rel="capabilities" href="/api/capabilities"/> <link rel="clusters" href="/api/clusters"/> <link rel="clusters/search" href="/api/clusters?search={query}"/> <link rel="datacenters" href="/api/datacenters"/> <link rel="datacenters/search" href="/api/datacenters?search={query}"/> <link rel="events" href="/api/events"/> <link rel="events/search" href="/api/events?search={query}"/> <link rel="hosts" href="/api/hosts"/> <link rel="hosts/search" href="/api/hosts?search={query}"/> <link rel="networks" href="/api/networks"/> <link rel="roles" href="/api/roles"/> <link rel="storagedomains" href="/api/storagedomains"/> <link rel="storagedomains/search" href="/api/storagedomains?search={query}"/> <link rel="tags" href="/api/tags"/> <link rel="templates" href="/api/templates"/> <link rel="templates/search" href="/api/templates?search={query}"/> <link rel="users" href="/api/users"/> <link rel="groups" href="/api/groups"/> <link rel="domains" href="/api/domains"/> <link rel="vmpools" href="/api/vmpools"/> <link rel="vmpools/search" href="/api/vmpools?search={query}"/> <link rel="vms" href="/api/vms"/> <link rel="vms/search" href="/api/vms?search={query}"/> <product_info> <name>oVirt Engine</name> <vendor>ovirt.org</vendor> <version> <build>4</build> <full_version>4.0.4</full_version> <major>4</major> <minor>0</minor> <revision>0</revision> </version> </product_info> <special_objects> <blank_template href="/ovirt-engine/api/templates/00000000-0000-0000-0000-000000000000" id="00000000-0000-0000-0000-000000000000"/> <root_tag href="/ovirt-engine/api/tags/00000000-0000-0000-0000-000000000000" id="00000000-0000-0000-0000-000000000000"/> </special_objects> <summary> <hosts> <active>0</active> <total>0</total> </hosts> <storage_domains> <active>0</active> <total>1</total> </storage_domains> <users> <active>1</active> <total>1</total> </users> <vms> <active>0</active> <total>0</total> </vms> </summary> <time>2016-09-14T12:00:48.132+02:00</time> </api> ---- The entry point provides a user with links to the collections in a virtualization environment. The `rel` attribute of each collection link provides a reference point for each link. The entry point also contains other data such as `product_info`, `special_objects` and `summary`. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns basic information describing the API, like the product name, the version number and a summary of the number of relevant objects.
[source]
GET /ovirt-engine/api
We get following response:
[source,xml]
The entry point provides a user with links to the collections in a
virtualization environment. The rel attribute of each collection link
provides a reference point for each link.
The entry point also contains other data such as product_info,
special_objects and summary.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def reload_configurations( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the reload should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reloadconfigurations', None, headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the reload should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def affinity_labels_service(self): """ List all known affinity labels. """ return AffinityLabelsService(self._connection, '%s/affinitylabels' % self._path)
List all known affinity labels.
View Source
def bookmarks_service(self): """ """ return BookmarksService(self._connection, '%s/bookmarks' % self._path)
View Source
def cluster_levels_service(self): """ Reference to the service that provides information about the cluster levels supported by the system. """ return ClusterLevelsService(self._connection, '%s/clusterlevels' % self._path)
Reference to the service that provides information about the cluster levels supported by the system.
View Source
def clusters_service(self): """ """ return ClustersService(self._connection, '%s/clusters' % self._path)
View Source
def cpu_profiles_service(self): """ """ return CpuProfilesService(self._connection, '%s/cpuprofiles' % self._path)
View Source
def data_centers_service(self): """ """ return DataCentersService(self._connection, '%s/datacenters' % self._path)
View Source
def disk_profiles_service(self): """ """ return DiskProfilesService(self._connection, '%s/diskprofiles' % self._path)
View Source
def disks_service(self): """ """ return DisksService(self._connection, '%s/disks' % self._path)
View Source
def domains_service(self): """ """ return DomainsService(self._connection, '%s/domains' % self._path)
View Source
def events_service(self): """ """ return EventsService(self._connection, '%s/events' % self._path)
View Source
def external_host_providers_service(self): """ """ return ExternalHostProvidersService(self._connection, '%s/externalhostproviders' % self._path)
View Source
def external_template_imports_service(self): """ Reference to service facilitating import of external templates. """ return ExternalTemplateImportsService(self._connection, '%s/externaltemplateimports' % self._path)
Reference to service facilitating import of external templates.
View Source
def external_vm_imports_service(self): """ Reference to service facilitating import of external virtual machines. """ return ExternalVmImportsService(self._connection, '%s/externalvmimports' % self._path)
Reference to service facilitating import of external virtual machines.
View Source
def groups_service(self): """ """ return GroupsService(self._connection, '%s/groups' % self._path)
View Source
def hosts_service(self): """ """ return HostsService(self._connection, '%s/hosts' % self._path)
View Source
def icons_service(self): """ """ return IconsService(self._connection, '%s/icons' % self._path)
View Source
def image_transfers_service(self): """ List of all image transfers being performed for image I/O in oVirt. """ return ImageTransfersService(self._connection, '%s/imagetransfers' % self._path)
List of all image transfers being performed for image I/O in oVirt.
View Source
def instance_types_service(self): """ """ return InstanceTypesService(self._connection, '%s/instancetypes' % self._path)
View Source
def jobs_service(self): """ List all the jobs monitored by the engine. """ return JobsService(self._connection, '%s/jobs' % self._path)
List all the jobs monitored by the engine.
View Source
def katello_errata_service(self): """ List the available Katello errata assigned to the engine. """ return EngineKatelloErrataService(self._connection, '%s/katelloerrata' % self._path)
List the available Katello errata assigned to the engine.
View Source
def mac_pools_service(self): """ """ return MacPoolsService(self._connection, '%s/macpools' % self._path)
View Source
def network_filters_service(self): """ Network filters will enhance the admin ability to manage the network packets traffic from/to the participated VMs. """ return NetworkFiltersService(self._connection, '%s/networkfilters' % self._path)
Network filters will enhance the admin ability to manage the network packets traffic from/to the participated VMs.
View Source
def networks_service(self): """ """ return NetworksService(self._connection, '%s/networks' % self._path)
View Source
def openstack_image_providers_service(self): """ """ return OpenstackImageProvidersService(self._connection, '%s/openstackimageproviders' % self._path)
View Source
def openstack_network_providers_service(self): """ """ return OpenstackNetworkProvidersService(self._connection, '%s/openstacknetworkproviders' % self._path)
View Source
def openstack_volume_providers_service(self): """ """ return OpenstackVolumeProvidersService(self._connection, '%s/openstackvolumeproviders' % self._path)
View Source
def operating_systems_service(self): """ """ return OperatingSystemsService(self._connection, '%s/operatingsystems' % self._path)
View Source
def options_service(self): """ Reference to the service that provides values of configuration options of the system. """ return SystemOptionsService(self._connection, '%s/options' % self._path)
Reference to the service that provides values of configuration options of the system.
View Source
def permissions_service(self): """ """ return SystemPermissionsService(self._connection, '%s/permissions' % self._path)
View Source
def roles_service(self): """ """ return RolesService(self._connection, '%s/roles' % self._path)
View Source
def scheduling_policies_service(self): """ """ return SchedulingPoliciesService(self._connection, '%s/schedulingpolicies' % self._path)
View Source
def scheduling_policy_units_service(self): """ """ return SchedulingPolicyUnitsService(self._connection, '%s/schedulingpolicyunits' % self._path)
View Source
def storage_connections_service(self): """ """ return StorageServerConnectionsService(self._connection, '%s/storageconnections' % self._path)
View Source
def storage_domains_service(self): """ """ return StorageDomainsService(self._connection, '%s/storagedomains' % self._path)
View Source
def templates_service(self): """ """ return TemplatesService(self._connection, '%s/templates' % self._path)
View Source
def users_service(self): """ """ return UsersService(self._connection, '%s/users' % self._path)
View Source
def vm_pools_service(self): """ """ return VmPoolsService(self._connection, '%s/vmpools' % self._path)
View Source
def vms_service(self): """ """ return VmsService(self._connection, '%s/vms' % self._path)
View Source
def vnic_profiles_service(self): """ """ return VnicProfilesService(self._connection, '%s/vnicprofiles' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'affinitylabels': return self.affinity_labels_service() if path.startswith('affinitylabels/'): return self.affinity_labels_service().service(path[15:]) if path == 'bookmarks': return self.bookmarks_service() if path.startswith('bookmarks/'): return self.bookmarks_service().service(path[10:]) if path == 'clusterlevels': return self.cluster_levels_service() if path.startswith('clusterlevels/'): return self.cluster_levels_service().service(path[14:]) if path == 'clusters': return self.clusters_service() if path.startswith('clusters/'): return self.clusters_service().service(path[9:]) if path == 'cpuprofiles': return self.cpu_profiles_service() if path.startswith('cpuprofiles/'): return self.cpu_profiles_service().service(path[12:]) if path == 'datacenters': return self.data_centers_service() if path.startswith('datacenters/'): return self.data_centers_service().service(path[12:]) if path == 'diskprofiles': return self.disk_profiles_service() if path.startswith('diskprofiles/'): return self.disk_profiles_service().service(path[13:]) if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) if path == 'domains': return self.domains_service() if path.startswith('domains/'): return self.domains_service().service(path[8:]) if path == 'events': return self.events_service() if path.startswith('events/'): return self.events_service().service(path[7:]) if path == 'externalhostproviders': return self.external_host_providers_service() if path.startswith('externalhostproviders/'): return self.external_host_providers_service().service(path[22:]) if path == 'externaltemplateimports': return self.external_template_imports_service() if path.startswith('externaltemplateimports/'): return self.external_template_imports_service().service(path[24:]) if path == 'externalvmimports': return self.external_vm_imports_service() if path.startswith('externalvmimports/'): return self.external_vm_imports_service().service(path[18:]) if path == 'groups': return self.groups_service() if path.startswith('groups/'): return self.groups_service().service(path[7:]) if path == 'hosts': return self.hosts_service() if path.startswith('hosts/'): return self.hosts_service().service(path[6:]) if path == 'icons': return self.icons_service() if path.startswith('icons/'): return self.icons_service().service(path[6:]) if path == 'imagetransfers': return self.image_transfers_service() if path.startswith('imagetransfers/'): return self.image_transfers_service().service(path[15:]) if path == 'instancetypes': return self.instance_types_service() if path.startswith('instancetypes/'): return self.instance_types_service().service(path[14:]) if path == 'jobs': return self.jobs_service() if path.startswith('jobs/'): return self.jobs_service().service(path[5:]) if path == 'katelloerrata': return self.katello_errata_service() if path.startswith('katelloerrata/'): return self.katello_errata_service().service(path[14:]) if path == 'macpools': return self.mac_pools_service() if path.startswith('macpools/'): return self.mac_pools_service().service(path[9:]) if path == 'networkfilters': return self.network_filters_service() if path.startswith('networkfilters/'): return self.network_filters_service().service(path[15:]) if path == 'networks': return self.networks_service() if path.startswith('networks/'): return self.networks_service().service(path[9:]) if path == 'openstackimageproviders': return self.openstack_image_providers_service() if path.startswith('openstackimageproviders/'): return self.openstack_image_providers_service().service(path[24:]) if path == 'openstacknetworkproviders': return self.openstack_network_providers_service() if path.startswith('openstacknetworkproviders/'): return self.openstack_network_providers_service().service(path[26:]) if path == 'openstackvolumeproviders': return self.openstack_volume_providers_service() if path.startswith('openstackvolumeproviders/'): return self.openstack_volume_providers_service().service(path[25:]) if path == 'operatingsystems': return self.operating_systems_service() if path.startswith('operatingsystems/'): return self.operating_systems_service().service(path[17:]) if path == 'options': return self.options_service() if path.startswith('options/'): return self.options_service().service(path[8:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'roles': return self.roles_service() if path.startswith('roles/'): return self.roles_service().service(path[6:]) if path == 'schedulingpolicies': return self.scheduling_policies_service() if path.startswith('schedulingpolicies/'): return self.scheduling_policies_service().service(path[19:]) if path == 'schedulingpolicyunits': return self.scheduling_policy_units_service() if path.startswith('schedulingpolicyunits/'): return self.scheduling_policy_units_service().service(path[22:]) if path == 'storageconnections': return self.storage_connections_service() if path.startswith('storageconnections/'): return self.storage_connections_service().service(path[19:]) if path == 'storagedomains': return self.storage_domains_service() if path.startswith('storagedomains/'): return self.storage_domains_service().service(path[15:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) if path == 'templates': return self.templates_service() if path.startswith('templates/'): return self.templates_service().service(path[10:]) if path == 'users': return self.users_service() if path.startswith('users/'): return self.users_service().service(path[6:]) if path == 'vmpools': return self.vm_pools_service() if path.startswith('vmpools/'): return self.vm_pools_service().service(path[8:]) if path == 'vms': return self.vms_service() if path.startswith('vms/'): return self.vms_service().service(path[4:]) if path == 'vnicprofiles': return self.vnic_profiles_service() if path.startswith('vnicprofiles/'): return self.vnic_profiles_service().service(path[13:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SystemOptionService(Service): """ A service that provides values of specific configuration option of the system. """ def __init__(self, connection, path): super(SystemOptionService, self).__init__(connection, path) def get( self, version=None, headers=None, query=None, wait=True, **kwargs ): """ Get the values of specific configuration option. For example to retrieve the values of configuration option `MigrationPoliciesSupported` send a request like this: [source] ---- GET /ovirt-engine/api/options/MigrationPoliciesSupported ---- The response to that request will be the following: [source,xml] ---- <system_option href="/ovirt-engine/api/options/MigrationPoliciesSupported" id="MigrationPoliciesSupported"> <name>MigrationPoliciesSupported</name> <values> <system_option_value> <value>true</value> <version>4.0</version> </system_option_value> <system_option_value> <value>true</value> <version>4.1</version> </system_option_value> <system_option_value> <value>true</value> <version>4.2</version> </system_option_value> <system_option_value> <value>false</value> <version>3.6</version> </system_option_value> </values> </system_option> ---- NOTE: The appropriate permissions are required to query configuration options. Some options can be queried only by users with administrator permissions. [IMPORTANT] ==== There is NO backward compatibility and no guarantee about the names or values of the options. Options may be removed and their meaning can be changed at any point. We strongly discourage the use of this service for applications other than the ones that are released simultaneously with the engine. Usage by other applications is not supported. Therefore there will be no documentation listing accessible configuration options. ==== This method supports the following parameters: `version`:: Optional version parameter that specifies that only particular version of the configuration option should be returned. If this parameter isn't used then all the versions will be returned. For example, to get the value of the `MigrationPoliciesSupported` option but only for version `4.2` send a request like this: [source] ---- GET /ovirt-engine/api/options/MigrationPoliciesSupported?version=4.2 ---- The response to that request will be like this: [source,xml] ---- <system_option href="/ovirt-engine/api/options/MigrationPoliciesSupported" id="MigrationPoliciesSupported"> <name>MigrationPoliciesSupported</name> <values> <system_option_value> <value>true</value> <version>4.2</version> </system_option_value> </values> </system_option> ---- `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('version', version, str), ]) # Build the URL: query = query or {} if version is not None: query['version'] = version # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'SystemOptionService:%s' % self._path
A service that provides values of specific configuration option of the system.
View Source
def __init__(self, connection, path): super(SystemOptionService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, version=None, headers=None, query=None, wait=True, **kwargs ): """ Get the values of specific configuration option. For example to retrieve the values of configuration option `MigrationPoliciesSupported` send a request like this: [source] ---- GET /ovirt-engine/api/options/MigrationPoliciesSupported ---- The response to that request will be the following: [source,xml] ---- <system_option href="/ovirt-engine/api/options/MigrationPoliciesSupported" id="MigrationPoliciesSupported"> <name>MigrationPoliciesSupported</name> <values> <system_option_value> <value>true</value> <version>4.0</version> </system_option_value> <system_option_value> <value>true</value> <version>4.1</version> </system_option_value> <system_option_value> <value>true</value> <version>4.2</version> </system_option_value> <system_option_value> <value>false</value> <version>3.6</version> </system_option_value> </values> </system_option> ---- NOTE: The appropriate permissions are required to query configuration options. Some options can be queried only by users with administrator permissions. [IMPORTANT] ==== There is NO backward compatibility and no guarantee about the names or values of the options. Options may be removed and their meaning can be changed at any point. We strongly discourage the use of this service for applications other than the ones that are released simultaneously with the engine. Usage by other applications is not supported. Therefore there will be no documentation listing accessible configuration options. ==== This method supports the following parameters: `version`:: Optional version parameter that specifies that only particular version of the configuration option should be returned. If this parameter isn't used then all the versions will be returned. For example, to get the value of the `MigrationPoliciesSupported` option but only for version `4.2` send a request like this: [source] ---- GET /ovirt-engine/api/options/MigrationPoliciesSupported?version=4.2 ---- The response to that request will be like this: [source,xml] ---- <system_option href="/ovirt-engine/api/options/MigrationPoliciesSupported" id="MigrationPoliciesSupported"> <name>MigrationPoliciesSupported</name> <values> <system_option_value> <value>true</value> <version>4.2</version> </system_option_value> </values> </system_option> ---- `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('version', version, str), ]) # Build the URL: query = query or {} if version is not None: query['version'] = version # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get the values of specific configuration option.
For example to retrieve the values of configuration option MigrationPoliciesSupported send a request like this:
[source]
GET /ovirt-engine/api/options/MigrationPoliciesSupported
The response to that request will be the following:
[source,xml]
NOTE: The appropriate permissions are required to query configuration options. Some options can be queried only by users with administrator permissions.
[IMPORTANT]
There is NO backward compatibility and no guarantee about the names or values of the options. Options may be removed and their meaning can be changed at any point. We strongly discourage the use of this service for applications other than the ones that are released simultaneously with the engine. Usage by other applications is not supported. Therefore there will be no
documentation listing accessible configuration options.
This method supports the following parameters:
version:: Optional version parameter that specifies that only particular version of the configuration option
should be returned.
If this parameter isn't used then all the versions will be returned.
For example, to get the value of the MigrationPoliciesSupported option but only for version 4.2 send
a request like this:
[source]
GET /ovirt-engine/api/options/MigrationPoliciesSupported?version=4.2
The response to that request will be like this:
[source,xml]
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SystemOptionsService(Service): """ Service that provides values of configuration options of the system. """ def __init__(self, connection, path): super(SystemOptionsService, self).__init__(connection, path) self._option_service = None def option_service(self, id): """ Returns a reference to the service that provides values of specific configuration option. """ Service._check_types([ ('id', id, str), ]) return SystemOptionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.option_service(path) return self.option_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SystemOptionsService:%s' % self._path
Service that provides values of configuration options of the system.
View Source
def __init__(self, connection, path): super(SystemOptionsService, self).__init__(connection, path) self._option_service = None
Creates a new service that will use the given connection and path.
View Source
def option_service(self, id): """ Returns a reference to the service that provides values of specific configuration option. """ Service._check_types([ ('id', id, str), ]) return SystemOptionService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service that provides values of specific configuration option.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.option_service(path) return self.option_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class SystemPermissionsService(AssignedPermissionsService): """ This service doesn't add any new methods, it is just a placeholder for the annotation that specifies the path of the resource that manages the permissions assigned to the system object. """ def __init__(self, connection, path): super(SystemPermissionsService, self).__init__(connection, path) self._permission_service = None def add( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Assign a new permission to a user or group for specific entity. For example, to assign the `UserVmManager` role to the virtual machine with id `123` to the user with id `456` send a request like this: .... POST /ovirt-engine/api/vms/123/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>UserVmManager</name> </role> <user id="456"/> </permission> ---- To assign the `SuperUser` role to the system to the user with id `456` send a request like this: .... POST /ovirt-engine/api/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>SuperUser</name> </role> <user id="456"/> </permission> ---- If you want to assign permission to the group instead of the user please replace the `user` element with the `group` element with proper `id` of the group. For example to assign the `UserRole` role to the cluster with id `123` to the group with id `789` send a request like this: .... POST /ovirt-engine/api/clusters/123/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>UserRole</name> </role> <group id="789"/> </permission> ---- This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_cluster_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the cluster to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_data_center_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the data center to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_group_level( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new group level permission for a given virtual machine. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_host_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the host to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List all the permissions of the specific entity. For example to list all the permissions of the cluster with id `123` send a request like this: .... GET /ovirt-engine/api/clusters/123/permissions .... [source,xml] ---- <permissions> <permission id="456"> <cluster id="123"/> <role id="789"/> <user id="451"/> </permission> <permission id="654"> <cluster id="123"/> <role id="789"/> <group id="127"/> </permission> </permissions> ---- The order of the returned permissions isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def add_storage_domain_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the storage domain to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_template_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the template to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_user_level( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new user level permission for a given virtual machine. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_vm_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the vm to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def add_vm_pool_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the vm pool to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait) def permission_service(self, id): """ Sub-resource locator method, returns individual permission resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return PermissionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.permission_service(path) return self.permission_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'SystemPermissionsService:%s' % self._path
This service doesn't add any new methods, it is just a placeholder for the annotation that specifies the path of the resource that manages the permissions assigned to the system object.
View Source
def __init__(self, connection, path): super(SystemPermissionsService, self).__init__(connection, path) self._permission_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Assign a new permission to a user or group for specific entity. For example, to assign the `UserVmManager` role to the virtual machine with id `123` to the user with id `456` send a request like this: .... POST /ovirt-engine/api/vms/123/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>UserVmManager</name> </role> <user id="456"/> </permission> ---- To assign the `SuperUser` role to the system to the user with id `456` send a request like this: .... POST /ovirt-engine/api/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>SuperUser</name> </role> <user id="456"/> </permission> ---- If you want to assign permission to the group instead of the user please replace the `user` element with the `group` element with proper `id` of the group. For example to assign the `UserRole` role to the cluster with id `123` to the group with id `789` send a request like this: .... POST /ovirt-engine/api/clusters/123/permissions .... With a request body like this: [source,xml] ---- <permission> <role> <name>UserRole</name> </role> <group id="789"/> </permission> ---- This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Assign a new permission to a user or group for specific entity.
For example, to assign the UserVmManager role to the virtual machine with id 123 to the user with id 456
send a request like this:
....
POST /ovirt-engine/api/vms/123/permissions
....
With a request body like this:
[source,xml]
To assign the SuperUser role to the system to the user with id 456 send a request like this:
....
POST /ovirt-engine/api/permissions
....
With a request body like this:
[source,xml]
If you want to assign permission to the group instead of the user please replace the user element with the
group element with proper id of the group. For example to assign the UserRole role to the cluster with
id 123 to the group with id 789 send a request like this:
....
POST /ovirt-engine/api/clusters/123/permissions
....
With a request body like this:
[source,xml]
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_cluster_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the cluster to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new permission on the cluster to the group in the system.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_data_center_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the data center to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new permission on the data center to the group in the system.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_group_level( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new group level permission for a given virtual machine. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new group level permission for a given virtual machine.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_host_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the host to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new permission on the host to the group in the system.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List all the permissions of the specific entity. For example to list all the permissions of the cluster with id `123` send a request like this: .... GET /ovirt-engine/api/clusters/123/permissions .... [source,xml] ---- <permissions> <permission id="456"> <cluster id="123"/> <role id="789"/> <user id="451"/> </permission> <permission id="654"> <cluster id="123"/> <role id="789"/> <group id="127"/> </permission> </permissions> ---- The order of the returned permissions isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List all the permissions of the specific entity.
For example to list all the permissions of the cluster with id 123 send a request like this:
....
GET /ovirt-engine/api/clusters/123/permissions
....
[source,xml]
The order of the returned permissions isn't guaranteed.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
add_storage_domain_permission(self, permission, headers=None, query=None, wait=True, **kwargs):
View Source
def add_storage_domain_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the storage domain to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new permission on the storage domain to the group in the system.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_template_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the template to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new permission on the template to the group in the system.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_user_level( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new user level permission for a given virtual machine. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new user level permission for a given virtual machine.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_vm_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the vm to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new permission on the vm to the group in the system.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def add_vm_pool_permission( self, permission, headers=None, query=None, wait=True, **kwargs ): """ Add a new permission on the vm pool to the group in the system. This method supports the following parameters: `permission`:: The permission. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('permission', permission, types.Permission), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(permission, headers, query, wait)
Add a new permission on the vm pool to the group in the system.
This method supports the following parameters:
permission:: The permission.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def permission_service(self, id): """ Sub-resource locator method, returns individual permission resource on which the remainder of the URI is dispatched. """ Service._check_types([ ('id', id, str), ]) return PermissionService(self._connection, '%s/%s' % (self._path, id))
Sub-resource locator method, returns individual permission resource on which the remainder of the URI is dispatched.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.permission_service(path) return self.permission_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TagService(Service): """ A service to manage a specific tag in the system. """ def __init__(self, connection, path): super(TagService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the information about the tag. For example to retrieve the information about the tag with the id `123` send a request like this: .... GET /ovirt-engine/api/tags/123 .... [source,xml] ---- <tag href="/ovirt-engine/api/tags/123" id="123"> <name>root</name> <description>root</description> </tag> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the tag from the system. For example to remove the tag with id `123` send a request like this: .... DELETE /ovirt-engine/api/tags/123 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, tag, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the tag entity. For example to update parent tag to tag with id `456` of the tag with id `123` send a request like this: .... PUT /ovirt-engine/api/tags/123 .... With request body like: [source,xml] ---- <tag> <parent id="456"/> </tag> ---- You may also specify a tag name instead of id. For example to update parent tag to tag with name `mytag` of the tag with id `123` send a request like this: [source,xml] ---- <tag> <parent> <name>mytag</name> </parent> </tag> ---- This method supports the following parameters: `tag`:: The updated tag. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('tag', tag, types.Tag), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(tag, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TagService:%s' % self._path
A service to manage a specific tag in the system.
View Source
def __init__(self, connection, path): super(TagService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the information about the tag. For example to retrieve the information about the tag with the id `123` send a request like this: .... GET /ovirt-engine/api/tags/123 .... [source,xml] ---- <tag href="/ovirt-engine/api/tags/123" id="123"> <name>root</name> <description>root</description> </tag> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets the information about the tag.
For example to retrieve the information about the tag with the id 123 send a request like this:
....
GET /ovirt-engine/api/tags/123
....
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the tag from the system. For example to remove the tag with id `123` send a request like this: .... DELETE /ovirt-engine/api/tags/123 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the tag from the system.
For example to remove the tag with id 123 send a request like this:
....
DELETE /ovirt-engine/api/tags/123
....
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, tag, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the tag entity. For example to update parent tag to tag with id `456` of the tag with id `123` send a request like this: .... PUT /ovirt-engine/api/tags/123 .... With request body like: [source,xml] ---- <tag> <parent id="456"/> </tag> ---- You may also specify a tag name instead of id. For example to update parent tag to tag with name `mytag` of the tag with id `123` send a request like this: [source,xml] ---- <tag> <parent> <name>mytag</name> </parent> </tag> ---- This method supports the following parameters: `tag`:: The updated tag. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('tag', tag, types.Tag), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(tag, headers, query, wait)
Updates the tag entity.
For example to update parent tag to tag with id 456 of the tag with id 123 send a request like this:
....
PUT /ovirt-engine/api/tags/123
....
With request body like:
[source,xml]
You may also specify a tag name instead of id. For example to update parent tag to tag with name mytag
of the tag with id 123 send a request like this:
[source,xml]
This method supports the following parameters:
tag:: The updated tag.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TagsService(Service): """ Represents a service to manage collection of the tags in the system. """ def __init__(self, connection, path): super(TagsService, self).__init__(connection, path) self._tag_service = None def add( self, tag, headers=None, query=None, wait=True, **kwargs ): """ Add a new tag to the system. For example, to add new tag with name `mytag` to the system send a request like this: .... POST /ovirt-engine/api/tags .... With a request body like this: [source,xml] ---- <tag> <name>mytag</name> </tag> ---- NOTE: The root tag is a special pseudo-tag assumed as the default parent tag if no parent tag is specified. The root tag cannot be deleted nor assigned a parent tag. To create new tag with specific parent tag send a request body like this: [source,xml] ---- <tag> <name>mytag</name> <parent> <name>myparenttag</name> </parent> </tag> ---- This method supports the following parameters: `tag`:: The added tag. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('tag', tag, types.Tag), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(tag, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the tags in the system. For example to list the full hierarchy of the tags in the system send a request like this: .... GET /ovirt-engine/api/tags .... [source,xml] ---- <tags> <tag href="/ovirt-engine/api/tags/222" id="222"> <name>root2</name> <description>root2</description> <parent href="/ovirt-engine/api/tags/111" id="111"/> </tag> <tag href="/ovirt-engine/api/tags/333" id="333"> <name>root3</name> <description>root3</description> <parent href="/ovirt-engine/api/tags/222" id="222"/> </tag> <tag href="/ovirt-engine/api/tags/111" id="111"> <name>root</name> <description>root</description> </tag> </tags> ---- In the previous XML output you can see the following hierarchy of the tags: .... root: (id: 111) - root2 (id: 222) - root3 (id: 333) .... The order of the returned list of tags isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of tags to return. If not specified all the tags are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def tag_service(self, id): """ Reference to the service that manages a specific tag. """ Service._check_types([ ('id', id, str), ]) return TagService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.tag_service(path) return self.tag_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TagsService:%s' % self._path
Represents a service to manage collection of the tags in the system.
View Source
def __init__(self, connection, path): super(TagsService, self).__init__(connection, path) self._tag_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, tag, headers=None, query=None, wait=True, **kwargs ): """ Add a new tag to the system. For example, to add new tag with name `mytag` to the system send a request like this: .... POST /ovirt-engine/api/tags .... With a request body like this: [source,xml] ---- <tag> <name>mytag</name> </tag> ---- NOTE: The root tag is a special pseudo-tag assumed as the default parent tag if no parent tag is specified. The root tag cannot be deleted nor assigned a parent tag. To create new tag with specific parent tag send a request body like this: [source,xml] ---- <tag> <name>mytag</name> <parent> <name>myparenttag</name> </parent> </tag> ---- This method supports the following parameters: `tag`:: The added tag. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('tag', tag, types.Tag), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(tag, headers, query, wait)
Add a new tag to the system.
For example, to add new tag with name mytag to the system send a request like this:
....
POST /ovirt-engine/api/tags
....
With a request body like this:
[source,xml]
NOTE: The root tag is a special pseudo-tag assumed as the default parent tag if no parent tag is specified. The root tag cannot be deleted nor assigned a parent tag. To create new tag with specific parent tag send a request body like this:
[source,xml]
This method supports the following parameters:
tag:: The added tag.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the tags in the system. For example to list the full hierarchy of the tags in the system send a request like this: .... GET /ovirt-engine/api/tags .... [source,xml] ---- <tags> <tag href="/ovirt-engine/api/tags/222" id="222"> <name>root2</name> <description>root2</description> <parent href="/ovirt-engine/api/tags/111" id="111"/> </tag> <tag href="/ovirt-engine/api/tags/333" id="333"> <name>root3</name> <description>root3</description> <parent href="/ovirt-engine/api/tags/222" id="222"/> </tag> <tag href="/ovirt-engine/api/tags/111" id="111"> <name>root</name> <description>root</description> </tag> </tags> ---- In the previous XML output you can see the following hierarchy of the tags: .... root: (id: 111) - root2 (id: 222) - root3 (id: 333) .... The order of the returned list of tags isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of tags to return. If not specified all the tags are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List the tags in the system. For example to list the full hierarchy of the tags in the system send a request like this: .... GET /ovirt-engine/api/tags ....
[source,xml]
In the previous XML output you can see the following hierarchy of the tags: .... root: (id: 111)
- root2 (id: 222)
- root3 (id: 333) .... The order of the returned list of tags isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of tags to return. If not specified all the tags are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def tag_service(self, id): """ Reference to the service that manages a specific tag. """ Service._check_types([ ('id', id, str), ]) return TagService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages a specific tag.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.tag_service(path) return self.tag_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TemplateService(Service): """ Manages the virtual machine template and template versions. """ def __init__(self, connection, path): super(TemplateService, self).__init__(connection, path) self._cdroms_service = None self._disk_attachments_service = None self._graphics_consoles_service = None self._nics_service = None self._permissions_service = None self._tags_service = None self._watchdogs_service = None def export( self, exclusive=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a template to the data center export domain. For example, send the following request: [source] ---- POST /ovirt-engine/api/templates/123/export ---- With a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> <exclusive>true<exclusive/> </action> ---- This method supports the following parameters: `exclusive`:: Indicates if the existing templates with the same name should be overwritten. The export action reports a failed action if a template of the same name exists in the destination domain. Set this parameter to `true` to change this behavior and overwrite any existing template. `storage_domain`:: Specifies the destination export storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( exclusive=exclusive, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about this template or template version. This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a virtual machine template. [source] ---- DELETE /ovirt-engine/api/templates/123 ---- This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def export_to_export_domain( self, exclusive=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a template to an export domain. This method supports the following parameters: `exclusive`:: Indicates if the existing templates with the same name should be overwritten. The export action reports a failed action if a template of the same name exists in the destination domain. Set this parameter to `true` to change this behavior and overwrite any existing template. `storage_domain`:: Specifies the destination export storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( exclusive=exclusive, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def export_to_path_on_host( self, directory=None, exclusive=None, filename=None, host=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a template as an OVA file to a given path on a specified host. This method supports the following parameters: `host`:: The host to generate the OVA file on. `directory`:: An absolute path of a directory on the host to generate the OVA file in. `filename`:: The name of the OVA file. This is an optional parameter. If it is not specified, the name of the OVA file is determined according to the name of the template. It will conform to the following pattern: "<template name>.ova". `exclusive`:: Indicates if the existing templates with the same name should be overwritten. The export action reports a failed action if a template of the same name exists in the destination domain. Set this parameter to `true` to change this behavior and overwrite any existing template. `storage_domain`:: Specifies the destination export storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('directory', directory, str), ('exclusive', exclusive, bool), ('filename', filename, str), ('host', host, types.Host), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( directory=directory, exclusive=exclusive, filename=filename, host=host, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def update( self, template, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the template. The `name`, `description`, `type`, `memory`, `cpu`, `topology`, `os`, `high_availability`, `display`, `stateless`, `usb`, and `timezone` elements can be updated after a template has been created. For example, to update a template so that it has 1 GiB of memory send a request like this: [source] ---- PUT /ovirt-engine/api/templates/123 ---- With the following request body: [source,xml] ---- <template> <memory>1073741824</memory> </template> ---- The `version_name` name attribute is the only one that can be updated within the `version` attribute used for template versions: [source,xml] ---- <template> <version> <version_name>mytemplate_2</version_name> </version> </template> ---- """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(template, headers, query, wait) def cdroms_service(self): """ Returns a reference to the service that manages the CD-ROMs that are associated with the template. """ return TemplateCdromsService(self._connection, '%s/cdroms' % self._path) def disk_attachments_service(self): """ Returns a reference to the service that manages a specific disk attachment of the template. """ return TemplateDiskAttachmentsService(self._connection, '%s/diskattachments' % self._path) def graphics_consoles_service(self): """ Returns a reference to the service that manages the graphical consoles that are associated with the template. """ return TemplateGraphicsConsolesService(self._connection, '%s/graphicsconsoles' % self._path) def nics_service(self): """ Returns a reference to the service that manages the NICs that are associated with the template. """ return TemplateNicsService(self._connection, '%s/nics' % self._path) def permissions_service(self): """ Returns a reference to the service that manages the permissions that are associated with the template. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def tags_service(self): """ Returns a reference to the service that manages the tags that are associated with the template. """ return AssignedTagsService(self._connection, '%s/tags' % self._path) def watchdogs_service(self): """ Returns a reference to the service that manages the _watchdogs_ that are associated with the template. """ return TemplateWatchdogsService(self._connection, '%s/watchdogs' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'cdroms': return self.cdroms_service() if path.startswith('cdroms/'): return self.cdroms_service().service(path[7:]) if path == 'diskattachments': return self.disk_attachments_service() if path.startswith('diskattachments/'): return self.disk_attachments_service().service(path[16:]) if path == 'graphicsconsoles': return self.graphics_consoles_service() if path.startswith('graphicsconsoles/'): return self.graphics_consoles_service().service(path[17:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) if path == 'watchdogs': return self.watchdogs_service() if path.startswith('watchdogs/'): return self.watchdogs_service().service(path[10:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TemplateService:%s' % self._path
Manages the virtual machine template and template versions.
View Source
def __init__(self, connection, path): super(TemplateService, self).__init__(connection, path) self._cdroms_service = None self._disk_attachments_service = None self._graphics_consoles_service = None self._nics_service = None self._permissions_service = None self._tags_service = None self._watchdogs_service = None
Creates a new service that will use the given connection and path.
#
def
export(
self,
exclusive=None,
storage_domain=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def export( self, exclusive=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a template to the data center export domain. For example, send the following request: [source] ---- POST /ovirt-engine/api/templates/123/export ---- With a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> <exclusive>true<exclusive/> </action> ---- This method supports the following parameters: `exclusive`:: Indicates if the existing templates with the same name should be overwritten. The export action reports a failed action if a template of the same name exists in the destination domain. Set this parameter to `true` to change this behavior and overwrite any existing template. `storage_domain`:: Specifies the destination export storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( exclusive=exclusive, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait)
Exports a template to the data center export domain. For example, send the following request:
[source]
POST /ovirt-engine/api/templates/123/export
With a request body like this:
[source,xml]
This method supports the following parameters:
exclusive:: Indicates if the existing templates with the same name should be overwritten.
The export action reports a failed action if a template of the same name exists in the destination domain.
Set this parameter to true to change this behavior and overwrite any existing template.
storage_domain:: Specifies the destination export storage domain.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about this template or template version. This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the information about this template or template version.
This method supports the following parameters:
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a virtual machine template. [source] ---- DELETE /ovirt-engine/api/templates/123 ---- This method supports the following parameters: `async_`:: Indicates if the removal should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes a virtual machine template.
[source]
DELETE /ovirt-engine/api/templates/123
This method supports the following parameters:
async_:: Indicates if the removal should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
export_to_export_domain(
self,
exclusive=None,
storage_domain=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def export_to_export_domain( self, exclusive=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a template to an export domain. This method supports the following parameters: `exclusive`:: Indicates if the existing templates with the same name should be overwritten. The export action reports a failed action if a template of the same name exists in the destination domain. Set this parameter to `true` to change this behavior and overwrite any existing template. `storage_domain`:: Specifies the destination export storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( exclusive=exclusive, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait)
Exports a template to an export domain.
This method supports the following parameters:
exclusive:: Indicates if the existing templates with the same name should be overwritten.
The export action reports a failed action if a template of the same name exists in the destination domain.
Set this parameter to true to change this behavior and overwrite any existing template.
storage_domain:: Specifies the destination export storage domain.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
export_to_path_on_host(
self,
directory=None,
exclusive=None,
filename=None,
host=None,
storage_domain=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def export_to_path_on_host( self, directory=None, exclusive=None, filename=None, host=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a template as an OVA file to a given path on a specified host. This method supports the following parameters: `host`:: The host to generate the OVA file on. `directory`:: An absolute path of a directory on the host to generate the OVA file in. `filename`:: The name of the OVA file. This is an optional parameter. If it is not specified, the name of the OVA file is determined according to the name of the template. It will conform to the following pattern: "<template name>.ova". `exclusive`:: Indicates if the existing templates with the same name should be overwritten. The export action reports a failed action if a template of the same name exists in the destination domain. Set this parameter to `true` to change this behavior and overwrite any existing template. `storage_domain`:: Specifies the destination export storage domain. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('directory', directory, str), ('exclusive', exclusive, bool), ('filename', filename, str), ('host', host, types.Host), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( directory=directory, exclusive=exclusive, filename=filename, host=host, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait)
Exports a template as an OVA file to a given path on a specified host.
This method supports the following parameters:
host:: The host to generate the OVA file on.
directory:: An absolute path of a directory on the host to generate the OVA file in.
filename:: The name of the OVA file.
This is an optional parameter. If it is not specified, the name of the OVA file is determined according
to the name of the template. It will conform to the following pattern: ".ova".
exclusive:: Indicates if the existing templates with the same name should be overwritten.
The export action reports a failed action if a template of the same name exists in the destination domain.
Set this parameter to true to change this behavior and overwrite any existing template.
storage_domain:: Specifies the destination export storage domain.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, template, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the template. The `name`, `description`, `type`, `memory`, `cpu`, `topology`, `os`, `high_availability`, `display`, `stateless`, `usb`, and `timezone` elements can be updated after a template has been created. For example, to update a template so that it has 1 GiB of memory send a request like this: [source] ---- PUT /ovirt-engine/api/templates/123 ---- With the following request body: [source,xml] ---- <template> <memory>1073741824</memory> </template> ---- The `version_name` name attribute is the only one that can be updated within the `version` attribute used for template versions: [source,xml] ---- <template> <version> <version_name>mytemplate_2</version_name> </version> </template> ---- """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(template, headers, query, wait)
Updates the template.
The name, description, type, memory, cpu, topology, os, high_availability, display,
stateless, usb, and timezone elements can be updated after a template has been created.
For example, to update a template so that it has 1 GiB of memory send a request like this:
[source]
PUT /ovirt-engine/api/templates/123
With the following request body:
[source,xml]
The version_name name attribute is the only one that can be updated within the version attribute used for
template versions:
[source,xml]
View Source
def cdroms_service(self): """ Returns a reference to the service that manages the CD-ROMs that are associated with the template. """ return TemplateCdromsService(self._connection, '%s/cdroms' % self._path)
Returns a reference to the service that manages the CD-ROMs that are associated with the template.
View Source
def disk_attachments_service(self): """ Returns a reference to the service that manages a specific disk attachment of the template. """ return TemplateDiskAttachmentsService(self._connection, '%s/diskattachments' % self._path)
Returns a reference to the service that manages a specific disk attachment of the template.
View Source
def graphics_consoles_service(self): """ Returns a reference to the service that manages the graphical consoles that are associated with the template. """ return TemplateGraphicsConsolesService(self._connection, '%s/graphicsconsoles' % self._path)
Returns a reference to the service that manages the graphical consoles that are associated with the template.
View Source
def nics_service(self): """ Returns a reference to the service that manages the NICs that are associated with the template. """ return TemplateNicsService(self._connection, '%s/nics' % self._path)
Returns a reference to the service that manages the NICs that are associated with the template.
View Source
def permissions_service(self): """ Returns a reference to the service that manages the permissions that are associated with the template. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
Returns a reference to the service that manages the permissions that are associated with the template.
View Source
def watchdogs_service(self): """ Returns a reference to the service that manages the _watchdogs_ that are associated with the template. """ return TemplateWatchdogsService(self._connection, '%s/watchdogs' % self._path)
Returns a reference to the service that manages the _watchdogs_ that are associated with the template.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'cdroms': return self.cdroms_service() if path.startswith('cdroms/'): return self.cdroms_service().service(path[7:]) if path == 'diskattachments': return self.disk_attachments_service() if path.startswith('diskattachments/'): return self.disk_attachments_service().service(path[16:]) if path == 'graphicsconsoles': return self.graphics_consoles_service() if path.startswith('graphicsconsoles/'): return self.graphics_consoles_service().service(path[17:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) if path == 'watchdogs': return self.watchdogs_service() if path.startswith('watchdogs/'): return self.watchdogs_service().service(path[10:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TemplateCdromService(Service): """ A service managing a CD-ROM device on templates. """ def __init__(self, connection, path): super(TemplateCdromService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about this CD-ROM device. For example, to get information about the CD-ROM device of template `123` send a request like: [source] ---- GET /ovirt-engine/api/templates/123/cdroms/ ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TemplateCdromService:%s' % self._path
A service managing a CD-ROM device on templates.
View Source
def __init__(self, connection, path): super(TemplateCdromService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about this CD-ROM device. For example, to get information about the CD-ROM device of template `123` send a request like: [source] ---- GET /ovirt-engine/api/templates/123/cdroms/ ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the information about this CD-ROM device.
For example, to get information about the CD-ROM device of template 123 send a request like:
[source]
GET /ovirt-engine/api/templates/123/cdroms/
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TemplateCdromsService(Service): """ Lists the CD-ROM devices of a template. """ def __init__(self, connection, path): super(TemplateCdromsService, self).__init__(connection, path) self._cdrom_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of CD-ROM devices of the template. The order of the returned list of CD-ROM devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of CD-ROMs to return. If not specified all the CD-ROMs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def cdrom_service(self, id): """ Returns a reference to the service that manages a specific CD-ROM device. """ Service._check_types([ ('id', id, str), ]) return TemplateCdromService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.cdrom_service(path) return self.cdrom_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TemplateCdromsService:%s' % self._path
Lists the CD-ROM devices of a template.
View Source
def __init__(self, connection, path): super(TemplateCdromsService, self).__init__(connection, path) self._cdrom_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of CD-ROM devices of the template. The order of the returned list of CD-ROM devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of CD-ROMs to return. If not specified all the CD-ROMs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of CD-ROM devices of the template. The order of the returned list of CD-ROM devices isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of CD-ROMs to return. If not specified all the CD-ROMs are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def cdrom_service(self, id): """ Returns a reference to the service that manages a specific CD-ROM device. """ Service._check_types([ ('id', id, str), ]) return TemplateCdromService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service that manages a specific CD-ROM device.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.cdrom_service(path) return self.cdrom_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TemplateDiskService(Service): """ """ def __init__(self, connection, path): super(TemplateDiskService, self).__init__(connection, path) def copy( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Copy the specified disk attached to the template to a specific storage domain. This method supports the following parameters: `async_`:: Indicates if the copy should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait) def export( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the export should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TemplateDiskService:%s' % self._path
View Source
def __init__(self, connection, path): super(TemplateDiskService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
#
def
copy(
self,
async_=None,
filter=None,
storage_domain=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def copy( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Copy the specified disk attached to the template to a specific storage domain. This method supports the following parameters: `async_`:: Indicates if the copy should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait)
Copy the specified disk attached to the template to a specific storage domain.
This method supports the following parameters:
async_:: Indicates if the copy should be performed asynchronously.
filter:: Indicates if the results should be filtered according to the permissions of the user.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
export(
self,
async_=None,
filter=None,
storage_domain=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def export( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the export should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the export should be performed asynchronously.
filter:: Indicates if the results should be filtered according to the permissions of the user.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TemplateDiskAttachmentService(Service): """ This service manages the attachment of a disk to a template. """ def __init__(self, connection, path): super(TemplateDiskAttachmentService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the details of the attachment. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, storage_domain=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the disk from the template. The disk will only be removed if there are other existing copies of the disk on other storage domains. A storage domain has to be specified to determine which of the copies should be removed (template disks can have copies on multiple storage domains). [source] ---- DELETE /ovirt-engine/api/templates/{template:id}/diskattachments/{attachment:id}?storage_domain=072fbaa1-08f3-4a40-9f34-a5ca22dd1d74 ---- This method supports the following parameters: `storage_domain`:: Specifies the identifier of the storage domain the image to be removed resides on. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, str), ('force', force, bool), ]) # Build the URL: query = query or {} if storage_domain is not None: query['storage_domain'] = storage_domain if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TemplateDiskAttachmentService:%s' % self._path
This service manages the attachment of a disk to a template.
View Source
def __init__(self, connection, path): super(TemplateDiskAttachmentService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the details of the attachment. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the details of the attachment.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
remove(
self,
storage_domain=None,
force=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def remove( self, storage_domain=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the disk from the template. The disk will only be removed if there are other existing copies of the disk on other storage domains. A storage domain has to be specified to determine which of the copies should be removed (template disks can have copies on multiple storage domains). [source] ---- DELETE /ovirt-engine/api/templates/{template:id}/diskattachments/{attachment:id}?storage_domain=072fbaa1-08f3-4a40-9f34-a5ca22dd1d74 ---- This method supports the following parameters: `storage_domain`:: Specifies the identifier of the storage domain the image to be removed resides on. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, str), ('force', force, bool), ]) # Build the URL: query = query or {} if storage_domain is not None: query['storage_domain'] = storage_domain if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the disk from the template. The disk will only be removed if there are other existing copies of the disk on other storage domains. A storage domain has to be specified to determine which of the copies should be removed (template disks can have copies on multiple storage domains).
[source]
DELETE /ovirt-engine/api/templates/{template:id}/diskattachments/{attachment:id}?storage_domain=072fbaa1-08f3-4a40-9f34-a5ca22dd1d74
This method supports the following parameters:
storage_domain:: Specifies the identifier of the storage domain the image to be removed resides on.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TemplateDiskAttachmentsService(Service): """ This service manages the set of disks attached to a template. Each attached disk is represented by a <<types/disk_attachment,DiskAttachment>>. """ def __init__(self, connection, path): super(TemplateDiskAttachmentsService, self).__init__(connection, path) self._attachment_service = None def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List the disks that are attached to the template. The order of the returned list of attachments isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def attachment_service(self, id): """ Reference to the service that manages a specific attachment. """ Service._check_types([ ('id', id, str), ]) return TemplateDiskAttachmentService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.attachment_service(path) return self.attachment_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TemplateDiskAttachmentsService:%s' % self._path
This service manages the set of disks attached to a template. Each attached disk is represented by a
<
View Source
def __init__(self, connection, path): super(TemplateDiskAttachmentsService, self).__init__(connection, path) self._attachment_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ List the disks that are attached to the template. The order of the returned list of attachments isn't guaranteed. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List the disks that are attached to the template. The order of the returned list of attachments isn't guaranteed.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def attachment_service(self, id): """ Reference to the service that manages a specific attachment. """ Service._check_types([ ('id', id, str), ]) return TemplateDiskAttachmentService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages a specific attachment.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.attachment_service(path) return self.attachment_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TemplateDisksService(Service): """ """ def __init__(self, connection, path): super(TemplateDisksService, self).__init__(connection, path) self._disk_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks of the template. The order of the returned list of disks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return TemplateDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TemplateDisksService:%s' % self._path
View Source
def __init__(self, connection, path): super(TemplateDisksService, self).__init__(connection, path) self._disk_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks of the template. The order of the returned list of disks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of disks of the template. The order of the returned list of disks isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of disks to return. If not specified all the disks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disk_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return TemplateDiskService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TemplateGraphicsConsoleService(Service): """ """ def __init__(self, connection, path): super(TemplateGraphicsConsoleService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets graphics console configuration of the template. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the graphics console from the template. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TemplateGraphicsConsoleService:%s' % self._path
View Source
def __init__(self, connection, path): super(TemplateGraphicsConsoleService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets graphics console configuration of the template. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets graphics console configuration of the template.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the graphics console from the template. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove the graphics console from the template.
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TemplateGraphicsConsolesService(Service): """ """ def __init__(self, connection, path): super(TemplateGraphicsConsolesService, self).__init__(connection, path) self._console_service = None def add( self, console, headers=None, query=None, wait=True, **kwargs ): """ Add new graphics console to the template. """ # Check the types of the parameters: Service._check_types([ ('console', console, types.GraphicsConsole), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(console, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured graphics consoles of the template. The order of the returned list of graphics consoles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of consoles to return. If not specified all the consoles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def console_service(self, id): """ Returns a reference to the service that manages a specific template graphics console. """ Service._check_types([ ('id', id, str), ]) return TemplateGraphicsConsoleService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.console_service(path) return self.console_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TemplateGraphicsConsolesService:%s' % self._path
View Source
def __init__(self, connection, path): super(TemplateGraphicsConsolesService, self).__init__(connection, path) self._console_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, console, headers=None, query=None, wait=True, **kwargs ): """ Add new graphics console to the template. """ # Check the types of the parameters: Service._check_types([ ('console', console, types.GraphicsConsole), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(console, headers, query, wait)
Add new graphics console to the template.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured graphics consoles of the template. The order of the returned list of graphics consoles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of consoles to return. If not specified all the consoles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists all the configured graphics consoles of the template. The order of the returned list of graphics consoles isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of consoles to return. If not specified all the consoles are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def console_service(self, id): """ Returns a reference to the service that manages a specific template graphics console. """ Service._check_types([ ('id', id, str), ]) return TemplateGraphicsConsoleService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service that manages a specific template graphics console.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.console_service(path) return self.console_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TemplateNicService(Service): """ """ def __init__(self, connection, path): super(TemplateNicService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, nic, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified network interface card attached to the template. """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(nic, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TemplateNicService:%s' % self._path
View Source
def __init__(self, connection, path): super(TemplateNicService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, nic, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified network interface card attached to the template. """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(nic, headers, query, wait)
Update the specified network interface card attached to the template.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TemplateNicsService(Service): """ """ def __init__(self, connection, path): super(TemplateNicsService, self).__init__(connection, path) self._nic_service = None def add( self, nic, headers=None, query=None, wait=True, **kwargs ): """ Add a new network interface card to the template. """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(nic, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of NICs of the template. The order of the returned list of NICs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def nic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return TemplateNicService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TemplateNicsService:%s' % self._path
View Source
def __init__(self, connection, path): super(TemplateNicsService, self).__init__(connection, path) self._nic_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, nic, headers=None, query=None, wait=True, **kwargs ): """ Add a new network interface card to the template. """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(nic, headers, query, wait)
Add a new network interface card to the template.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of NICs of the template. The order of the returned list of NICs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of NICs of the template. The order of the returned list of NICs isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of NICs to return. If not specified all the NICs are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def nic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return TemplateNicService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TemplateWatchdogService(Service): """ """ def __init__(self, connection, path): super(TemplateWatchdogService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, watchdog, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the watchdog for the template identified by the given id. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(watchdog, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'TemplateWatchdogService:%s' % self._path
View Source
def __init__(self, connection, path): super(TemplateWatchdogService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, watchdog, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the watchdog for the template identified by the given id. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(watchdog, headers, query, wait)
Update the watchdog for the template identified by the given id.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TemplateWatchdogsService(Service): """ """ def __init__(self, connection, path): super(TemplateWatchdogsService, self).__init__(connection, path) self._watchdog_service = None def add( self, watchdog, headers=None, query=None, wait=True, **kwargs ): """ Add a watchdog to the template identified by the given id. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(watchdog, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of watchdogs. The order of the returned list of watchdogs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of watchdogs to return. If not specified all the watchdogs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def watchdog_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return TemplateWatchdogService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.watchdog_service(path) return self.watchdog_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TemplateWatchdogsService:%s' % self._path
View Source
def __init__(self, connection, path): super(TemplateWatchdogsService, self).__init__(connection, path) self._watchdog_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, watchdog, headers=None, query=None, wait=True, **kwargs ): """ Add a watchdog to the template identified by the given id. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(watchdog, headers, query, wait)
Add a watchdog to the template identified by the given id.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of watchdogs. The order of the returned list of watchdogs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of watchdogs to return. If not specified all the watchdogs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of watchdogs. The order of the returned list of watchdogs isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of watchdogs to return. If not specified all the watchdogs are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def watchdog_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return TemplateWatchdogService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.watchdog_service(path) return self.watchdog_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class TemplatesService(Service): """ This service manages the virtual machine templates available in the system. """ def __init__(self, connection, path): super(TemplatesService, self).__init__(connection, path) self._template_service = None def add( self, template, clone_permissions=None, seal=None, headers=None, query=None, wait=True, **kwargs ): """ Creates a new template. This requires the `name` and `vm` elements. To identify the virtual machine use the `vm.id` or `vm.name` attributes. For example, to create a template from a virtual machine with the identifier `123` send a request like this: [source] ---- POST /ovirt-engine/api/templates ---- With a request body like this: [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"/> </template> ---- Since version 4.3, in order to create virtual machine template from a snapshot send a request body like this: [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"> <snapshots> <snapshot id="456"/> </snapshots> </vm> </template> ---- The disks of the template can be customized, making some of their characteristics different from the disks of the original virtual machine. To do so use the `vm.disk_attachments` attribute, specifying the identifier of the disk of the original virtual machine and the characteristics that you want to change. For example, if the original virtual machine has a disk with the identifier `456`, and, for that disk, you want to change the name to `mydisk` the format to <<types/disk_format, _Copy On Write_>> and make it <<types/disk, sparse>>, send a request body like this: [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"> <disk_attachments> <disk_attachment> <disk id="456"> <name>mydisk</name> <format>cow</format> <sparse>true</sparse> </disk> </disk_attachment> </disk_attachments> </vm> </template> ---- The template can be created as a sub-version of an existing template. This requires the `name` and `vm` attributes for the new template, and the `base_template` and `version_name` attributes for the new template version. The `base_template` and `version_name` attributes must be specified within a `version` section enclosed in the `template` section. Identify the virtual machine with the `id` or `name` attributes. [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"/> <version> <base_template id="456"/> <version_name>mytemplate_001</version_name> </version> </template> ---- The destination storage domain of the template can be customized, in one of two ways: 1. Globally, at the request level. The request must list the desired disk attachments to be created on the storage domain. If the disk attachments are not listed, the global storage domain parameter will be ignored. + [source,xml] ---- <template> <name>mytemplate</name> <storage_domain id="123"/> <vm id="456"> <disk_attachments> <disk_attachment> <disk id="789"> <format>cow</format> <sparse>true</sparse> </disk> </disk_attachment> </disk_attachments> </vm> </template> ---- 2. Per each disk attachment. Specify the desired storage domain for each disk attachment. Specifying the global storage definition will override the storage domain per disk attachment specification. + [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"> <disk_attachments> <disk_attachment> <disk id="456"> <format>cow</format> <sparse>true</sparse> <storage_domains> <storage_domain id="789"/> </storage_domains> </disk> </disk_attachment> </disk_attachments> </vm> </template> ---- This method supports the following parameters: `template`:: The information about the template or template version. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('clone_permissions', clone_permissions, bool), ('seal', seal, bool), ]) # Build the URL: query = query or {} if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if seal is not None: seal = Writer.render_boolean(seal) query['seal'] = seal # Send the request and wait for the response: return self._internal_add(template, headers, query, wait) def add_from_configuration( self, template, clone_permissions=None, seal=None, headers=None, query=None, wait=True, **kwargs ): """ Add a virtual machine template to the system from a configuration. Requires the configuration type, the configuration data, and the target cluster. This method supports the following parameters: `template`:: The information about the template or template version. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('clone_permissions', clone_permissions, bool), ('seal', seal, bool), ]) # Build the URL: query = query or {} if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if seal is not None: seal = Writer.render_boolean(seal) query['seal'] = seal # Send the request and wait for the response: return self._internal_add(template, headers, query, wait) def add_from_vm( self, template, clone_permissions=None, seal=None, headers=None, query=None, wait=True, **kwargs ): """ Add a virtual machine template to the system from an existing virtual machine. This method supports the following parameters: `template`:: The information about the template or template version. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('clone_permissions', clone_permissions, bool), ('seal', seal, bool), ]) # Build the URL: query = query or {} if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if seal is not None: seal = Writer.render_boolean(seal) query['seal'] = seal # Send the request and wait for the response: return self._internal_add(template, headers, query, wait) def add_from_vm_snapshot( self, template, clone_permissions=None, seal=None, headers=None, query=None, wait=True, **kwargs ): """ Add a virtual machine template to the system from a snapshot. This method supports the following parameters: `template`:: The information about the template or template version. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('clone_permissions', clone_permissions, bool), ('seal', seal, bool), ]) # Build the URL: query = query or {} if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if seal is not None: seal = Writer.render_boolean(seal) query['seal'] = seal # Send the request and wait for the response: return self._internal_add(template, headers, query, wait) def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of virtual machine templates. For example: [source] ---- GET /ovirt-engine/api/templates ---- Will return the list of virtual machines and virtual machine templates. The order of the returned list of templates is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of templates to return. If not specified, all the templates are returned. `search`:: A query string used to restrict the returned templates. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def template_service(self, id): """ Returns a reference to the service that manages a specific virtual machine template. """ Service._check_types([ ('id', id, str), ]) return TemplateService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.template_service(path) return self.template_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'TemplatesService:%s' % self._path
This service manages the virtual machine templates available in the system.
View Source
def __init__(self, connection, path): super(TemplatesService, self).__init__(connection, path) self._template_service = None
Creates a new service that will use the given connection and path.
#
def
add(
self,
template,
clone_permissions=None,
seal=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def add( self, template, clone_permissions=None, seal=None, headers=None, query=None, wait=True, **kwargs ): """ Creates a new template. This requires the `name` and `vm` elements. To identify the virtual machine use the `vm.id` or `vm.name` attributes. For example, to create a template from a virtual machine with the identifier `123` send a request like this: [source] ---- POST /ovirt-engine/api/templates ---- With a request body like this: [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"/> </template> ---- Since version 4.3, in order to create virtual machine template from a snapshot send a request body like this: [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"> <snapshots> <snapshot id="456"/> </snapshots> </vm> </template> ---- The disks of the template can be customized, making some of their characteristics different from the disks of the original virtual machine. To do so use the `vm.disk_attachments` attribute, specifying the identifier of the disk of the original virtual machine and the characteristics that you want to change. For example, if the original virtual machine has a disk with the identifier `456`, and, for that disk, you want to change the name to `mydisk` the format to <<types/disk_format, _Copy On Write_>> and make it <<types/disk, sparse>>, send a request body like this: [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"> <disk_attachments> <disk_attachment> <disk id="456"> <name>mydisk</name> <format>cow</format> <sparse>true</sparse> </disk> </disk_attachment> </disk_attachments> </vm> </template> ---- The template can be created as a sub-version of an existing template. This requires the `name` and `vm` attributes for the new template, and the `base_template` and `version_name` attributes for the new template version. The `base_template` and `version_name` attributes must be specified within a `version` section enclosed in the `template` section. Identify the virtual machine with the `id` or `name` attributes. [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"/> <version> <base_template id="456"/> <version_name>mytemplate_001</version_name> </version> </template> ---- The destination storage domain of the template can be customized, in one of two ways: 1. Globally, at the request level. The request must list the desired disk attachments to be created on the storage domain. If the disk attachments are not listed, the global storage domain parameter will be ignored. + [source,xml] ---- <template> <name>mytemplate</name> <storage_domain id="123"/> <vm id="456"> <disk_attachments> <disk_attachment> <disk id="789"> <format>cow</format> <sparse>true</sparse> </disk> </disk_attachment> </disk_attachments> </vm> </template> ---- 2. Per each disk attachment. Specify the desired storage domain for each disk attachment. Specifying the global storage definition will override the storage domain per disk attachment specification. + [source,xml] ---- <template> <name>mytemplate</name> <vm id="123"> <disk_attachments> <disk_attachment> <disk id="456"> <format>cow</format> <sparse>true</sparse> <storage_domains> <storage_domain id="789"/> </storage_domains> </disk> </disk_attachment> </disk_attachments> </vm> </template> ---- This method supports the following parameters: `template`:: The information about the template or template version. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('clone_permissions', clone_permissions, bool), ('seal', seal, bool), ]) # Build the URL: query = query or {} if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if seal is not None: seal = Writer.render_boolean(seal) query['seal'] = seal # Send the request and wait for the response: return self._internal_add(template, headers, query, wait)
Creates a new template.
This requires the name and vm elements. To identify the virtual machine use the vm.id or vm.name
attributes. For example, to create a template from a virtual machine with the identifier 123 send a request
like this:
[source]
POST /ovirt-engine/api/templates
With a request body like this:
[source,xml]
Since version 4.3, in order to create virtual machine template from a snapshot send a request body like this:
[source,xml]
The disks of the template can be customized, making some of their characteristics different from the disks of the
original virtual machine. To do so use the vm.disk_attachments attribute, specifying the identifier of the disk
of the original virtual machine and the characteristics that you want to change. For example, if the original
virtual machine has a disk with the identifier 456, and, for that disk, you want to change the name to mydisk
the format to <
[source,xml]
The template can be created as a sub-version of an existing template. This requires the name and vm attributes
for the new template, and the base_template and version_name attributes for the new template version. The
base_template and version_name attributes must be specified within a version section enclosed in the
template section. Identify the virtual machine with the id or name attributes.
[source,xml]
The destination storage domain of the template can be customized, in one of two ways:
- Globally, at the request level. The request must list the desired disk attachments to be created on the storage domain. If the disk attachments are not listed, the global storage domain parameter will be ignored. +
[source,xml]
- Per each disk attachment. Specify the desired storage domain for each disk attachment.
Specifying the global storage definition will override the storage domain per disk attachment specification.
+
[source,xml]
This method supports the following parameters:
template:: The information about the template or template version.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
add_from_configuration(
self,
template,
clone_permissions=None,
seal=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def add_from_configuration( self, template, clone_permissions=None, seal=None, headers=None, query=None, wait=True, **kwargs ): """ Add a virtual machine template to the system from a configuration. Requires the configuration type, the configuration data, and the target cluster. This method supports the following parameters: `template`:: The information about the template or template version. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('clone_permissions', clone_permissions, bool), ('seal', seal, bool), ]) # Build the URL: query = query or {} if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if seal is not None: seal = Writer.render_boolean(seal) query['seal'] = seal # Send the request and wait for the response: return self._internal_add(template, headers, query, wait)
Add a virtual machine template to the system from a configuration. Requires the configuration type, the configuration data, and the target cluster.
This method supports the following parameters:
template:: The information about the template or template version.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
add_from_vm(
self,
template,
clone_permissions=None,
seal=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def add_from_vm( self, template, clone_permissions=None, seal=None, headers=None, query=None, wait=True, **kwargs ): """ Add a virtual machine template to the system from an existing virtual machine. This method supports the following parameters: `template`:: The information about the template or template version. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('clone_permissions', clone_permissions, bool), ('seal', seal, bool), ]) # Build the URL: query = query or {} if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if seal is not None: seal = Writer.render_boolean(seal) query['seal'] = seal # Send the request and wait for the response: return self._internal_add(template, headers, query, wait)
Add a virtual machine template to the system from an existing virtual machine.
This method supports the following parameters:
template:: The information about the template or template version.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
add_from_vm_snapshot(
self,
template,
clone_permissions=None,
seal=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def add_from_vm_snapshot( self, template, clone_permissions=None, seal=None, headers=None, query=None, wait=True, **kwargs ): """ Add a virtual machine template to the system from a snapshot. This method supports the following parameters: `template`:: The information about the template or template version. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('template', template, types.Template), ('clone_permissions', clone_permissions, bool), ('seal', seal, bool), ]) # Build the URL: query = query or {} if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if seal is not None: seal = Writer.render_boolean(seal) query['seal'] = seal # Send the request and wait for the response: return self._internal_add(template, headers, query, wait)
Add a virtual machine template to the system from a snapshot.
This method supports the following parameters:
template:: The information about the template or template version.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
list(
self,
case_sensitive=None,
filter=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of virtual machine templates. For example: [source] ---- GET /ovirt-engine/api/templates ---- Will return the list of virtual machines and virtual machine templates. The order of the returned list of templates is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of templates to return. If not specified, all the templates are returned. `search`:: A query string used to restrict the returned templates. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of virtual machine templates. For example:
[source]
GET /ovirt-engine/api/templates
Will return the list of virtual machines and virtual machine templates. The order of the returned list of templates is not guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of templates to return. If not specified, all the templates are returned.
search:: A query string used to restrict the returned templates.
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def template_service(self, id): """ Returns a reference to the service that manages a specific virtual machine template. """ Service._check_types([ ('id', id, str), ]) return TemplateService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service that manages a specific virtual machine template.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.template_service(path) return self.template_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class UnmanagedNetworkService(Service): """ """ def __init__(self, connection, path): super(UnmanagedNetworkService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'UnmanagedNetworkService:%s' % self._path
View Source
def __init__(self, connection, path): super(UnmanagedNetworkService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class UnmanagedNetworksService(Service): """ """ def __init__(self, connection, path): super(UnmanagedNetworksService, self).__init__(connection, path) self._unmanaged_network_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of unmanaged networks of the host. The order of the returned list of networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def unmanaged_network_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return UnmanagedNetworkService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.unmanaged_network_service(path) return self.unmanaged_network_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'UnmanagedNetworksService:%s' % self._path
View Source
def __init__(self, connection, path): super(UnmanagedNetworksService, self).__init__(connection, path) self._unmanaged_network_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of unmanaged networks of the host. The order of the returned list of networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of unmanaged networks of the host. The order of the returned list of networks isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of networks to return. If not specified all the networks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def unmanaged_network_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return UnmanagedNetworkService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.unmanaged_network_service(path) return self.unmanaged_network_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class UserService(Service): """ A service to manage a user in the system. Use this service to either get users details or remove users. In order to add new users please use <<services/users>>. """ def __init__(self, connection, path): super(UserService, self).__init__(connection, path) self._event_subscriptions_service = None self._groups_service = None self._options_service = None self._permissions_service = None self._roles_service = None self._ssh_public_keys_service = None self._tags_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the system user information. Usage: .... GET /ovirt-engine/api/users/1234 .... Will return the user information: [source,xml] ---- <user href="/ovirt-engine/api/users/1234" id="1234"> <name>admin</name> <link href="/ovirt-engine/api/users/1234/sshpublickeys" rel="sshpublickeys"/> <link href="/ovirt-engine/api/users/1234/roles" rel="roles"/> <link href="/ovirt-engine/api/users/1234/permissions" rel="permissions"/> <link href="/ovirt-engine/api/users/1234/tags" rel="tags"/> <department></department> <domain_entry_id>23456</domain_entry_id> <email>user1@domain.com</email> <last_name>Lastname</last_name> <namespace>*</namespace> <principal>user1</principal> <user_name>user1@domain-authz</user_name> <domain href="/ovirt-engine/api/domains/45678" id="45678"> <name>domain-authz</name> </domain> </user> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the system user. Usage: .... DELETE /ovirt-engine/api/users/1234 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, user, headers=None, query=None, wait=True, **kwargs ): """ Updates information about the user. Only the `user_options` field can be updated. For example, to update user options: [source] ---- PUT /ovirt-engine/api/users/123 ---- With a request body like this: [source,xml] ---- <user> <user_options> <property> <name>test</name> <value>["any","JSON"]</value> </property> </user_options> </user> ---- IMPORTANT: Since version 4.4.5 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. Please use the <<services/user_option, options>> endpoint instead. """ # Check the types of the parameters: Service._check_types([ ('user', user, types.User), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(user, headers, query, wait) def event_subscriptions_service(self): """ List of event-subscriptions for this user. """ return EventSubscriptionsService(self._connection, '%s/eventsubscriptions' % self._path) def groups_service(self): """ """ return DomainUserGroupsService(self._connection, '%s/groups' % self._path) def options_service(self): """ """ return UserOptionsService(self._connection, '%s/options' % self._path) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def roles_service(self): """ """ return AssignedRolesService(self._connection, '%s/roles' % self._path) def ssh_public_keys_service(self): """ """ return SshPublicKeysService(self._connection, '%s/sshpublickeys' % self._path) def tags_service(self): """ """ return AssignedTagsService(self._connection, '%s/tags' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'eventsubscriptions': return self.event_subscriptions_service() if path.startswith('eventsubscriptions/'): return self.event_subscriptions_service().service(path[19:]) if path == 'groups': return self.groups_service() if path.startswith('groups/'): return self.groups_service().service(path[7:]) if path == 'options': return self.options_service() if path.startswith('options/'): return self.options_service().service(path[8:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'roles': return self.roles_service() if path.startswith('roles/'): return self.roles_service().service(path[6:]) if path == 'sshpublickeys': return self.ssh_public_keys_service() if path.startswith('sshpublickeys/'): return self.ssh_public_keys_service().service(path[14:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'UserService:%s' % self._path
A service to manage a user in the system.
Use this service to either get users details or remove users.
In order to add new users please use
<
View Source
def __init__(self, connection, path): super(UserService, self).__init__(connection, path) self._event_subscriptions_service = None self._groups_service = None self._options_service = None self._permissions_service = None self._roles_service = None self._ssh_public_keys_service = None self._tags_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the system user information. Usage: .... GET /ovirt-engine/api/users/1234 .... Will return the user information: [source,xml] ---- <user href="/ovirt-engine/api/users/1234" id="1234"> <name>admin</name> <link href="/ovirt-engine/api/users/1234/sshpublickeys" rel="sshpublickeys"/> <link href="/ovirt-engine/api/users/1234/roles" rel="roles"/> <link href="/ovirt-engine/api/users/1234/permissions" rel="permissions"/> <link href="/ovirt-engine/api/users/1234/tags" rel="tags"/> <department></department> <domain_entry_id>23456</domain_entry_id> <email>user1@domain.com</email> <last_name>Lastname</last_name> <namespace>*</namespace> <principal>user1</principal> <user_name>user1@domain-authz</user_name> <domain href="/ovirt-engine/api/domains/45678" id="45678"> <name>domain-authz</name> </domain> </user> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets the system user information. Usage: .... GET /ovirt-engine/api/users/1234 .... Will return the user information:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the system user. Usage: .... DELETE /ovirt-engine/api/users/1234 .... This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the system user. Usage: .... DELETE /ovirt-engine/api/users/1234 ....
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, user, headers=None, query=None, wait=True, **kwargs ): """ Updates information about the user. Only the `user_options` field can be updated. For example, to update user options: [source] ---- PUT /ovirt-engine/api/users/123 ---- With a request body like this: [source,xml] ---- <user> <user_options> <property> <name>test</name> <value>["any","JSON"]</value> </property> </user_options> </user> ---- IMPORTANT: Since version 4.4.5 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. Please use the <<services/user_option, options>> endpoint instead. """ # Check the types of the parameters: Service._check_types([ ('user', user, types.User), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(user, headers, query, wait)
Updates information about the user.
Only the user_options field can be updated.
For example, to update user options:
[source]
PUT /ovirt-engine/api/users/123
With a request body like this:
[source,xml]
IMPORTANT: Since version 4.4.5 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. Please use the <
View Source
def event_subscriptions_service(self): """ List of event-subscriptions for this user. """ return EventSubscriptionsService(self._connection, '%s/eventsubscriptions' % self._path)
List of event-subscriptions for this user.
View Source
def groups_service(self): """ """ return DomainUserGroupsService(self._connection, '%s/groups' % self._path)
View Source
def options_service(self): """ """ return UserOptionsService(self._connection, '%s/options' % self._path)
View Source
def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
View Source
def roles_service(self): """ """ return AssignedRolesService(self._connection, '%s/roles' % self._path)
View Source
def ssh_public_keys_service(self): """ """ return SshPublicKeysService(self._connection, '%s/sshpublickeys' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'eventsubscriptions': return self.event_subscriptions_service() if path.startswith('eventsubscriptions/'): return self.event_subscriptions_service().service(path[19:]) if path == 'groups': return self.groups_service() if path.startswith('groups/'): return self.groups_service().service(path[7:]) if path == 'options': return self.options_service() if path.startswith('options/'): return self.options_service().service(path[8:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'roles': return self.roles_service() if path.startswith('roles/'): return self.roles_service().service(path[6:]) if path == 'sshpublickeys': return self.ssh_public_keys_service() if path.startswith('sshpublickeys/'): return self.ssh_public_keys_service().service(path[14:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class UserOptionService(Service): """ """ def __init__(self, connection, path): super(UserOptionService, self).__init__(connection, path) def get( self, headers=None, query=None, wait=True, **kwargs ): """ Returns a user profile property of type JSON. Example request(for user with identifier `123` and option with identifier `456`): [source] ---- GET /ovirt-engine/api/users/123/options/456 ---- The result will be the following XML document: [source,xml] ---- <user_option href="/ovirt-engine/api/users/123/options/456" id="456"> <name>SomeName</name> <content>["any", "JSON"]</content> <user href="/ovirt-engine/api/users/123" id="123"/> </user_option> ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Deletes an existing property of type JSON. Example request(for user with identifier `123` and option with identifier `456`): [source] ---- DELETE /ovirt-engine/api/users/123/options/456 ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'UserOptionService:%s' % self._path
View Source
def __init__(self, connection, path): super(UserOptionService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, headers=None, query=None, wait=True, **kwargs ): """ Returns a user profile property of type JSON. Example request(for user with identifier `123` and option with identifier `456`): [source] ---- GET /ovirt-engine/api/users/123/options/456 ---- The result will be the following XML document: [source,xml] ---- <user_option href="/ovirt-engine/api/users/123/options/456" id="456"> <name>SomeName</name> <content>["any", "JSON"]</content> <user href="/ovirt-engine/api/users/123" id="123"/> </user_option> ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns a user profile property of type JSON.
Example request(for user with identifier 123 and option with identifier 456):
[source]
GET /ovirt-engine/api/users/123/options/456
The result will be the following XML document:
[source,xml]
View Source
def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Deletes an existing property of type JSON. Example request(for user with identifier `123` and option with identifier `456`): [source] ---- DELETE /ovirt-engine/api/users/123/options/456 ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Deletes an existing property of type JSON.
Example request(for user with identifier 123 and option with identifier 456):
[source]
DELETE /ovirt-engine/api/users/123/options/456
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class UserOptionsService(Service): """ """ def __init__(self, connection, path): super(UserOptionsService, self).__init__(connection, path) self._option_service = None def add( self, option, headers=None, query=None, wait=True, **kwargs ): """ Adds a new user profile property of type JSON. Example request(for user with identifier `123`): [source] ---- POST /ovirt-engine/api/users/123/options ---- Payload: [source,xml] ---- <user_option> <name>SomeName</name> <content>["any", "JSON"]</content> </user_option> ---- """ # Check the types of the parameters: Service._check_types([ ('option', option, types.UserOption), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(option, headers, query, wait) def list( self, headers=None, query=None, wait=True, **kwargs ): """ Returns a list of user profile properties of type JSON. Example request(for user with identifier `123`): [source] ---- GET /ovirt-engine/api/users/123/options ---- The result will be the following XML document: [source,xml] ---- <user_options> <user_option href="/ovirt-engine/api/users/123/options/456" id="456"> <name>SomeName</name> <content>["any", "JSON"]</content> <user href="/ovirt-engine/api/users/123" id="123"/> </user_option> </user_options> ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_get(headers, query, wait) def option_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return UserOptionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.option_service(path) return self.option_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'UserOptionsService:%s' % self._path
View Source
def __init__(self, connection, path): super(UserOptionsService, self).__init__(connection, path) self._option_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, option, headers=None, query=None, wait=True, **kwargs ): """ Adds a new user profile property of type JSON. Example request(for user with identifier `123`): [source] ---- POST /ovirt-engine/api/users/123/options ---- Payload: [source,xml] ---- <user_option> <name>SomeName</name> <content>["any", "JSON"]</content> </user_option> ---- """ # Check the types of the parameters: Service._check_types([ ('option', option, types.UserOption), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(option, headers, query, wait)
Adds a new user profile property of type JSON.
Example request(for user with identifier 123):
[source]
POST /ovirt-engine/api/users/123/options
Payload:
[source,xml]
View Source
def list( self, headers=None, query=None, wait=True, **kwargs ): """ Returns a list of user profile properties of type JSON. Example request(for user with identifier `123`): [source] ---- GET /ovirt-engine/api/users/123/options ---- The result will be the following XML document: [source,xml] ---- <user_options> <user_option href="/ovirt-engine/api/users/123/options/456" id="456"> <name>SomeName</name> <content>["any", "JSON"]</content> <user href="/ovirt-engine/api/users/123" id="123"/> </user_option> </user_options> ---- """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns a list of user profile properties of type JSON.
Example request(for user with identifier 123):
[source]
GET /ovirt-engine/api/users/123/options
The result will be the following XML document:
[source,xml]
View Source
def option_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return UserOptionService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.option_service(path) return self.option_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class UsersService(Service): """ A service to manage the users in the system. """ def __init__(self, connection, path): super(UsersService, self).__init__(connection, path) self._user_service = None def add( self, user, headers=None, query=None, wait=True, **kwargs ): """ Add user from a directory service. For example, to add the `myuser` user from the `myextension-authz` authorization provider send a request like this: [source] ---- POST /ovirt-engine/api/users ---- With a request body like this: [source,xml] ---- <user> <user_name>myuser@myextension-authz</user_name> <domain> <name>myextension-authz</name> </domain> </user> ---- In case you are working with Active Directory you have to pass user principal name (UPN) as `username`, followed by authorization provider name. Due to https://bugzilla.redhat.com/1147900[bug 1147900] you need to provide also `principal` parameter set to UPN of the user. For example, to add the user with UPN `myuser@mysubdomain.mydomain.com` from the `myextension-authz` authorization provider send a request body like this: [source,xml] ---- <user> <principal>myuser@mysubdomain.mydomain.com</principal> <user_name>myuser@mysubdomain.mydomain.com@myextension-authz</user_name> <domain> <name>myextension-authz</name> </domain> </user> ---- """ # Check the types of the parameters: Service._check_types([ ('user', user, types.User), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(user, headers, query, wait) def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ List all the users in the system. Usage: .... GET /ovirt-engine/api/users .... Will return the list of users: [source,xml] ---- <users> <user href="/ovirt-engine/api/users/1234" id="1234"> <name>admin</name> <link href="/ovirt-engine/api/users/1234/sshpublickeys" rel="sshpublickeys"/> <link href="/ovirt-engine/api/users/1234/roles" rel="roles"/> <link href="/ovirt-engine/api/users/1234/permissions" rel="permissions"/> <link href="/ovirt-engine/api/users/1234/tags" rel="tags"/> <domain_entry_id>23456</domain_entry_id> <namespace>*</namespace> <principal>user1</principal> <user_name>user1@domain-authz</user_name> <domain href="/ovirt-engine/api/domains/45678" id="45678"> <name>domain-authz</name> </domain> </user> </users> ---- The order of the returned list of users isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of users to return. If not specified all the users are returned. `search`:: A query string used to restrict the returned users. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def user_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return UserService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.user_service(path) return self.user_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'UsersService:%s' % self._path
A service to manage the users in the system.
View Source
def __init__(self, connection, path): super(UsersService, self).__init__(connection, path) self._user_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, user, headers=None, query=None, wait=True, **kwargs ): """ Add user from a directory service. For example, to add the `myuser` user from the `myextension-authz` authorization provider send a request like this: [source] ---- POST /ovirt-engine/api/users ---- With a request body like this: [source,xml] ---- <user> <user_name>myuser@myextension-authz</user_name> <domain> <name>myextension-authz</name> </domain> </user> ---- In case you are working with Active Directory you have to pass user principal name (UPN) as `username`, followed by authorization provider name. Due to https://bugzilla.redhat.com/1147900[bug 1147900] you need to provide also `principal` parameter set to UPN of the user. For example, to add the user with UPN `myuser@mysubdomain.mydomain.com` from the `myextension-authz` authorization provider send a request body like this: [source,xml] ---- <user> <principal>myuser@mysubdomain.mydomain.com</principal> <user_name>myuser@mysubdomain.mydomain.com@myextension-authz</user_name> <domain> <name>myextension-authz</name> </domain> </user> ---- """ # Check the types of the parameters: Service._check_types([ ('user', user, types.User), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(user, headers, query, wait)
Add user from a directory service.
For example, to add the myuser user from the myextension-authz authorization provider send a request
like this:
[source]
POST /ovirt-engine/api/users
With a request body like this:
[source,xml]
In case you are working with Active Directory you have to pass user principal name (UPN) as username, followed
by authorization provider name. Due to https://bugzilla.redhat.com/1147900[bug 1147900] you need to provide
also principal parameter set to UPN of the user.
For example, to add the user with UPN myuser@mysubdomain.mydomain.com from the myextension-authz
authorization provider send a request body like this:
[source,xml]
#
def
list(
self,
case_sensitive=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ List all the users in the system. Usage: .... GET /ovirt-engine/api/users .... Will return the list of users: [source,xml] ---- <users> <user href="/ovirt-engine/api/users/1234" id="1234"> <name>admin</name> <link href="/ovirt-engine/api/users/1234/sshpublickeys" rel="sshpublickeys"/> <link href="/ovirt-engine/api/users/1234/roles" rel="roles"/> <link href="/ovirt-engine/api/users/1234/permissions" rel="permissions"/> <link href="/ovirt-engine/api/users/1234/tags" rel="tags"/> <domain_entry_id>23456</domain_entry_id> <namespace>*</namespace> <principal>user1</principal> <user_name>user1@domain-authz</user_name> <domain href="/ovirt-engine/api/domains/45678" id="45678"> <name>domain-authz</name> </domain> </user> </users> ---- The order of the returned list of users isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of users to return. If not specified all the users are returned. `search`:: A query string used to restrict the returned users. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List all the users in the system. Usage: .... GET /ovirt-engine/api/users .... Will return the list of users:
[source,xml]
The order of the returned list of users isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of users to return. If not specified all the users are returned.
search:: A query string used to restrict the returned users.
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def user_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return UserService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.user_service(path) return self.user_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VirtualFunctionAllowedNetworkService(Service): """ """ def __init__(self, connection, path): super(VirtualFunctionAllowedNetworkService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VirtualFunctionAllowedNetworkService:%s' % self._path
View Source
def __init__(self, connection, path): super(VirtualFunctionAllowedNetworkService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VirtualFunctionAllowedNetworksService(Service): """ """ def __init__(self, connection, path): super(VirtualFunctionAllowedNetworksService, self).__init__(connection, path) self._network_service = None def add( self, network, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(network, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of networks. The order of the returned list of networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def network_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VirtualFunctionAllowedNetworkService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VirtualFunctionAllowedNetworksService:%s' % self._path
View Source
def __init__(self, connection, path): super(VirtualFunctionAllowedNetworksService, self).__init__(connection, path) self._network_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, network, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('network', network, types.Network), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(network, headers, query, wait)
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of networks. The order of the returned list of networks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of networks to return. If not specified all the networks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of networks. The order of the returned list of networks isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of networks to return. If not specified all the networks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def network_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VirtualFunctionAllowedNetworkService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.network_service(path) return self.network_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmService(MeasurableService): """ """ def __init__(self, connection, path): super(VmService, self).__init__(connection, path) self._affinity_labels_service = None self._applications_service = None self._backups_service = None self._cdroms_service = None self._checkpoints_service = None self._disk_attachments_service = None self._graphics_consoles_service = None self._host_devices_service = None self._katello_errata_service = None self._nics_service = None self._numa_nodes_service = None self._permissions_service = None self._reported_devices_service = None self._sessions_service = None self._snapshots_service = None self._statistics_service = None self._tags_service = None self._watchdogs_service = None def auto_pin_cpu_and_numa_nodes( self, async_=None, optimize_cpu_settings=None, headers=None, query=None, wait=True, **kwargs ): """ Apply an automatic CPU and NUMA configuration on the VM. An example for a request: [source] ---- POST /ovirt-engine/api/vms/123/autopincpuandnumanodes ---- With a request body like this: [source,xml] ---- <action> <optimize_cpu_settings>true</optimize_cpu_settings> </action> ---- This method supports the following parameters: `optimize_cpu_settings`:: Specifies how the auto CPU and NUMA configuration is applied. If set to true, will adjust the CPU topology to fit the VM pinned host hardware. Otherwise, it will use the VM CPU topology. `async_`:: Indicates if the detach action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('optimize_cpu_settings', optimize_cpu_settings, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, optimize_cpu_settings=optimize_cpu_settings, ) # Send the request and wait for the response: return self._internal_action(action, 'autopincpuandnumanodes', None, headers, query, wait) def cancel_migration( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation stops any migration of a virtual machine to another physical host. [source] ---- POST /ovirt-engine/api/vms/123/cancelmigration ---- The cancel migration action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the migration should cancelled asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'cancelmigration', None, headers, query, wait) def clone( self, async_=None, discard_snapshots=None, storage_domain=None, vm=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the clone should be performed asynchronously. `discard_snapshots`:: Use the `discard_snapshots` parameter when the virtual machine should be clone with its snapshots collapsed. Default is true. `storage_domain`:: The storage domain on which the virtual machines disks will be copied to. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('discard_snapshots', discard_snapshots, bool), ('storage_domain', storage_domain, types.StorageDomain), ('vm', vm, types.Vm), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, discard_snapshots=discard_snapshots, storage_domain=storage_domain, vm=vm, ) # Send the request and wait for the response: return self._internal_action(action, 'clone', None, headers, query, wait) def commit_snapshot( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Permanently restores the virtual machine to the state of the previewed snapshot. See the <<services/vm/methods/preview_snapshot, preview_snapshot>> operation for details. This method supports the following parameters: `async_`:: Indicates if the snapshots should be committed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'commitsnapshot', None, headers, query, wait) def detach( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Detaches a virtual machine from a pool. [source] ---- POST /ovirt-engine/api/vms/123/detach ---- The detach action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the detach action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'detach', None, headers, query, wait) def export( self, async_=None, discard_snapshots=None, exclusive=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports the virtual machine. A virtual machine can be exported to an export domain. For example, to export virtual machine `123` to the export domain `myexport`: [source] ---- POST /ovirt-engine/api/vms/123/export ---- With a request body like this: [source,xml] ---- <action> <storage_domain> <name>myexport</name> </storage_domain> <exclusive>true</exclusive> <discard_snapshots>true</discard_snapshots> </action> ---- Since version 4.2 of the engine it is also possible to export a virtual machine as a virtual appliance (OVA). For example, to export virtual machine `123` as an OVA file named `myvm.ova` that is placed in the directory `/home/ovirt/` on host `myhost`: [source] ---- POST /ovirt-engine/api/vms/123/export ---- With a request body like this: [source,xml] ---- <action> <host> <name>myhost</name> </host> <directory>/home/ovirt</directory> <filename>myvm.ova</filename> </action> ---- NOTE: Confirm that the export operation has completed before attempting any actions on the export domain. This method supports the following parameters: `discard_snapshots`:: Use the `discard_snapshots` parameter when the virtual machine should be exported with all of its snapshots collapsed. `exclusive`:: Use the `exclusive` parameter when the virtual machine should be exported even if another copy of it already exists in the export domain (override). `storage_domain`:: The (export) storage domain to export the virtual machine to. `async_`:: Indicates if the export should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('discard_snapshots', discard_snapshots, bool), ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, discard_snapshots=discard_snapshots, exclusive=exclusive, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def freeze_filesystems( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Freezes virtual machine file systems. This operation freezes a virtual machine's file systems using the QEMU guest agent when taking a live snapshot of a running virtual machine. Normally, this is done automatically by the manager, but this must be executed manually with the API for virtual machines using OpenStack Volume (Cinder) disks. Example: [source] ---- POST /ovirt-engine/api/vms/123/freezefilesystems ---- [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the freeze should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'freezefilesystems', None, headers, query, wait) def get( self, all_content=None, filter=None, follow=None, next_run=None, ovf_as_ova=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the virtual machine. This method supports the following parameters: `next_run`:: Indicates if the returned result describes the virtual machine as it is currently running or if describes the virtual machine with the modifications that have already been performed but that will only come into effect when the virtual machine is restarted. By default the value is `false`. If the parameter is included in the request, but without a value, it is assumed that the value is `true`. The the following request: [source] ---- GET /vms/{vm:id};next_run ---- Is equivalent to using the value `true`: [source] ---- GET /vms/{vm:id};next_run=true ---- `all_content`:: Indicates if all of the attributes of the virtual machine should be included in the response. By default the following attributes are excluded: - `console` - `initialization.configuration.data` - The OVF document describing the virtual machine. - `rng_source` - `soundcard` - `virtio_scsi` For example, to retrieve the complete representation of the virtual machine '123': .... GET /ovirt-engine/api/vms/123?all_content=true .... NOTE: These attributes are not included by default as they reduce performance. These attributes are seldom used and require additional queries to the database. Only use this parameter when required as it will reduce performance. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `ovf_as_ova`:: Indicates if the results should expose the OVF as it appears in OVA files of that VM. The OVF document describing the virtual machine. This parameter will work only when all_content=True is set. The OVF will be presented in `initialization.configuration.data`. For example: [source] ---- GET /vms/{vm:id}?all_content=true&ovf_as_ova=true ---- `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('filter', filter, bool), ('follow', follow, str), ('next_run', next_run, bool), ('ovf_as_ova', ovf_as_ova, bool), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if next_run is not None: next_run = Writer.render_boolean(next_run) query['next_run'] = next_run if ovf_as_ova is not None: ovf_as_ova = Writer.render_boolean(ovf_as_ova) query['ovf_as_ova'] = ovf_as_ova # Send the request and wait for the response: return self._internal_get(headers, query, wait) def logon( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Initiates the automatic user logon to access a virtual machine from an external console. This action requires the `ovirt-guest-agent-gdm-plugin` and the `ovirt-guest-agent-pam-module` packages to be installed and the `ovirt-guest-agent` service to be running on the virtual machine. Users require the appropriate user permissions for the virtual machine in order to access the virtual machine from an external console. For example: [source] ---- POST /ovirt-engine/api/vms/123/logon ---- Request body: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the logon should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'logon', None, headers, query, wait) def maintenance( self, async_=None, maintenance_enabled=None, headers=None, query=None, wait=True, **kwargs ): """ Sets the global maintenance mode on the hosted engine virtual machine. This action has no effect on other virtual machines. Example: [source] ---- POST /ovirt-engine/api/vms/123/maintenance ---- [source,xml] ---- <action> <maintenance_enabled>true<maintenance_enabled/> </action> ---- This method supports the following parameters: `maintenance_enabled`:: Indicates if global maintenance should be enabled or disabled. `async_`:: Indicates if the global maintenance action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('maintenance_enabled', maintenance_enabled, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, maintenance_enabled=maintenance_enabled, ) # Send the request and wait for the response: return self._internal_action(action, 'maintenance', None, headers, query, wait) def migrate( self, async_=None, cluster=None, force=None, host=None, migrate_vms_in_affinity_closure=None, headers=None, query=None, wait=True, **kwargs ): """ Migrates a virtual machine to another physical host. Example: [source] ---- POST /ovirt-engine/api/vms/123/migrate ---- To specify a specific host to migrate the virtual machine to: [source,xml] ---- <action> <host id="2ab5e1da-b726-4274-bbf7-0a42b16a0fc3"/> </action> ---- This method supports the following parameters: `cluster`:: Specifies the cluster the virtual machine should migrate to. This is an optional parameter. By default, the virtual machine is migrated to another host within the same cluster. WARNING: Live migration to another cluster is not supported. Strongly consider the target cluster's hardware architecture and network architecture before attempting a migration. `force`:: Specifies that the virtual machine should migrate even if the virtual machine is defined as non-migratable. This is an optional parameter. By default, it is set to `false`. `host`:: Specifies a specific host that the virtual machine should migrate to. This is an optional parameter. By default, the {engine-name} automatically selects a default host for migration within the same cluster. If an API user requires a specific host, the user can specify the host with either an `id` or `name` parameter. `migrate_vms_in_affinity_closure`:: Migrate also all other virtual machines in positive enforcing affinity groups with this virtual machine, that are running on the same host. The default value is `false`. `async_`:: Indicates if the migration should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('force', force, bool), ('host', host, types.Host), ('migrate_vms_in_affinity_closure', migrate_vms_in_affinity_closure, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, cluster=cluster, force=force, host=host, migrate_vms_in_affinity_closure=migrate_vms_in_affinity_closure, ) # Send the request and wait for the response: return self._internal_action(action, 'migrate', None, headers, query, wait) def preview_snapshot( self, async_=None, disks=None, lease=None, restore_memory=None, snapshot=None, vm=None, headers=None, query=None, wait=True, **kwargs ): """ Temporarily restores the virtual machine to the state of a snapshot. The snapshot is indicated with the `snapshot.id` parameter. It is restored temporarily, so that the content can be inspected. Once that inspection is finished, the state of the virtual machine can be made permanent, using the <<services/vm/methods/commit_snapshot, commit_snapshot>> method, or discarded using the <<services/vm/methods/undo_snapshot, undo_snapshot>> method. This method supports the following parameters: `disks`:: Specify the disks included in the snapshot's preview. For each disk parameter, it is also required to specify its `image_id`. For example, to preview a snapshot with identifier `456` which includes a disk with identifier `111` and its `image_id` as `222`, send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/previewsnapshot ---- Request body: [source,xml] ---- <action> <disks> <disk id="111"> <image_id>222</image_id> </disk> </disks> <snapshot id="456"/> </action> ---- `lease`:: Specify the lease storage domain ID to use in the preview of the snapshot. If lease parameter is not passed, then the previewed snapshot lease storage domain will be used. If lease parameter is passed with empty storage domain parameter, then no lease will be used for the snapshot preview. If lease parameter is passed with storage domain parameter then the storage domain ID can be only one of the leases domain IDs that belongs to one of the virtual machine snapshots. This is an optional parameter, set by default to `null` `async_`:: Indicates if the preview should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('disks', disks, list), ('lease', lease, types.StorageDomainLease), ('restore_memory', restore_memory, bool), ('snapshot', snapshot, types.Snapshot), ('vm', vm, types.Vm), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, disks=disks, lease=lease, restore_memory=restore_memory, snapshot=snapshot, vm=vm, ) # Send the request and wait for the response: return self._internal_action(action, 'previewsnapshot', None, headers, query, wait) def reboot( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Sends a reboot request to a virtual machine. For example: [source] ---- POST /ovirt-engine/api/vms/123/reboot ---- The reboot action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- To reboot the VM even if a backup is running for it, the action should include the 'force' element. For example, to force reboot virtual machine `123`: ---- POST /ovirt-engine/api/vms/123/reboot ---- [source,xml] ---- <action> <force>true</force> </action> ---- This method supports the following parameters: `force`:: Indicates if the VM should be forcibly rebooted even if a backup is running for it. `async_`:: Indicates if the reboot should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'reboot', None, headers, query, wait) def remove( self, async_=None, detach_only=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the virtual machine, including the virtual disks attached to it. For example, to remove the virtual machine with identifier `123`: [source] ---- DELETE /ovirt-engine/api/vms/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `detach_only`:: Indicates if the attached virtual disks should be detached first and preserved instead of being removed. `force`:: Indicates if the virtual machine should be forcibly removed. Locked virtual machines and virtual machines with locked disk images cannot be removed without this flag set to true. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('detach_only', detach_only, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if detach_only is not None: detach_only = Writer.render_boolean(detach_only) query['detach_only'] = detach_only if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: self._internal_remove(headers, query, wait) def reorder_mac_addresses( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reordermacaddresses', None, headers, query, wait) def reset( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Sends a reset request to a virtual machine. For example: [source] ---- POST /ovirt-engine/api/vms/123/reset ---- The reset action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the reset should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reset', None, headers, query, wait) def shutdown( self, async_=None, force=None, reason=None, headers=None, query=None, wait=True, **kwargs ): """ This operation sends a shutdown request to a virtual machine. For example: [source] ---- POST /ovirt-engine/api/vms/123/shutdown ---- The shutdown action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- To shutdown the VM even if a backup is running for it, the action should include the 'force' element. For example, to force shutdown virtual machine `123`: ---- POST /ovirt-engine/api/vms/123/shutdown ---- [source,xml] ---- <action> <force>true</force> </action> ---- This method supports the following parameters: `force`:: Indicates if the VM should be forcibly shutdown even if a backup is running for it. `async_`:: Indicates if the shutdown should be performed asynchronously. `reason`:: The reason the virtual machine was stopped. Optionally set by user when shutting down the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('reason', reason, str), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, reason=reason, ) # Send the request and wait for the response: return self._internal_action(action, 'shutdown', None, headers, query, wait) def start( self, async_=None, authorized_key=None, filter=None, pause=None, use_cloud_init=None, use_ignition=None, use_initialization=None, use_sysprep=None, vm=None, volatile=None, headers=None, query=None, wait=True, **kwargs ): """ Starts the virtual machine. If the virtual environment is complete and the virtual machine contains all necessary components to function, it can be started. This example starts the virtual machine: [source] ---- POST /ovirt-engine/api/vms/123/start ---- With a request body: [source,xml] ---- <action/> ---- This method supports the following parameters: `pause`:: If set to `true`, start the virtual machine in paused mode. The default is `false`. `vm`:: The definition of the virtual machine for this specific run. For example: [source,xml] ---- <action> <vm> <os> <boot> <devices> <device>cdrom</device> </devices> </boot> </os> </vm> </action> ---- This will set the boot device to the CDROM only for this specific start. After the virtual machine is powered off, this definition will be reverted. `use_cloud_init`:: If set to `true`, the initialization type is set to _cloud-init_. The default value is `false`. See https://cloudinit.readthedocs.io/en/latest[this] for details. `use_sysprep`:: If set to `true`, the initialization type is set to _Sysprep_. The default value is `false`. See https://en.wikipedia.org/wiki/Sysprep[this] for details. `use_ignition`:: If set to `true`, the initialization type is set to _Ignition_. The default value is `false`. See https://coreos.com/ignition/docs/latest/[this] for details. `use_initialization`:: If set to `true`, the initialization type is set by the VM's OS. Windows will set to _Sysprep_, Linux to _cloud-init_ and RedHat CoreOS to _Ignition_. If any of the initialization-types are explicitly set (useCloudInit, useSysprep or useIgnition), they will be prioritized and this flag will be ignored. The default value is `false`. `async_`:: Indicates if the start action should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `volatile`:: Indicates that this run configuration will be discarded even in the case of guest-initiated reboot. The default value is `false`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('authorized_key', authorized_key, types.AuthorizedKey), ('filter', filter, bool), ('pause', pause, bool), ('use_cloud_init', use_cloud_init, bool), ('use_ignition', use_ignition, bool), ('use_initialization', use_initialization, bool), ('use_sysprep', use_sysprep, bool), ('vm', vm, types.Vm), ('volatile', volatile, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, authorized_key=authorized_key, filter=filter, pause=pause, use_cloud_init=use_cloud_init, use_ignition=use_ignition, use_initialization=use_initialization, use_sysprep=use_sysprep, vm=vm, volatile=volatile, ) # Send the request and wait for the response: return self._internal_action(action, 'start', None, headers, query, wait) def stop( self, async_=None, force=None, reason=None, headers=None, query=None, wait=True, **kwargs ): """ This operation forces a virtual machine to power-off. For example: [source] ---- POST /ovirt-engine/api/vms/123/stop ---- The stop action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- To stop the VM even if a backup is running for it, the action should include the 'force' element. For example, to force stop virtual machine `123`: ---- POST /ovirt-engine/api/vms/123/stop ---- [source,xml] ---- <action> <force>true</force> </action> ---- This method supports the following parameters: `force`:: Indicates if the VM should be forcibly stop even if a backup is running for it. `async_`:: Indicates if the stop action should be performed asynchronously. `reason`:: The reason the virtual machine was stopped. Optionally set by user when shutting down the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('reason', reason, str), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, reason=reason, ) # Send the request and wait for the response: return self._internal_action(action, 'stop', None, headers, query, wait) def suspend( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation saves the virtual machine state to disk and stops it. Start a suspended virtual machine and restore the virtual machine state with the start action. For example: [source] ---- POST /ovirt-engine/api/vms/123/suspend ---- The suspend action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the suspend action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'suspend', None, headers, query, wait) def thaw_filesystems( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Thaws virtual machine file systems. This operation thaws a virtual machine's file systems using the QEMU guest agent when taking a live snapshot of a running virtual machine. Normally, this is done automatically by the manager, but this must be executed manually with the API for virtual machines using OpenStack Volume (Cinder) disks. Example: [source] ---- POST /api/vms/123/thawfilesystems ---- [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the thaw file systems action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'thawfilesystems', None, headers, query, wait) def ticket( self, async_=None, ticket=None, headers=None, query=None, wait=True, **kwargs ): """ Generates a time-sensitive authentication token for accessing a virtual machine's display. For example: [source] ---- POST /ovirt-engine/api/vms/123/ticket ---- The client-provided action optionally includes a desired ticket value and/or an expiry time in seconds. The response specifies the actual ticket value and expiry used. [source,xml] ---- <action> <ticket> <value>abcd12345</value> <expiry>120</expiry> </ticket> </action> ---- [IMPORTANT] ==== If the virtual machine is configured to support only one graphics protocol then the generated authentication token will be valid for that protocol. But if the virtual machine is configured to support multiple protocols, VNC and SPICE, then the authentication token will only be valid for the SPICE protocol. In order to obtain an authentication token for a specific protocol, for example for VNC, use the `ticket` method of the <<services/vm_graphics_console, service>>, which manages the graphics consoles of the virtual machine, by sending a request: [source] ---- POST /ovirt-engine/api/vms/123/graphicsconsoles/456/ticket ---- ==== This method supports the following parameters: `async_`:: Indicates if the generation of the ticket should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('ticket', ticket, types.Ticket), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ticket=ticket, ) # Send the request and wait for the response: return self._internal_action(action, 'ticket', 'ticket', headers, query, wait) def export_to_export_domain( self, async_=None, discard_snapshots=None, exclusive=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a virtual machine to an export domain. This method supports the following parameters: `discard_snapshots`:: Use the `discard_snapshots` parameter when the virtual machine should be exported with all of its snapshots collapsed. `exclusive`:: Use the `exclusive` parameter when the virtual machine should be exported even if another copy of it already exists in the export domain (override). `storage_domain`:: The (export) storage domain to export the virtual machine to. `async_`:: Indicates if the export should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('discard_snapshots', discard_snapshots, bool), ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, discard_snapshots=discard_snapshots, exclusive=exclusive, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def export_to_path_on_host( self, async_=None, directory=None, discard_snapshots=None, exclusive=None, filename=None, host=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a virtual machine as an OVA file to a given path on a specified host. This method supports the following parameters: `host`:: The host to generate the OVA file on. `directory`:: An absolute path of a directory on the host to generate the OVA file in. `filename`:: The name of the OVA file. This is an optional parameter, if it is not specified then the name of OVA file is determined according to the name of the virtual machine. It will conform the following pattern: "<virtual machine name>.ova". `discard_snapshots`:: Use the `discard_snapshots` parameter when the virtual machine should be exported with all of its snapshots collapsed. `exclusive`:: Use the `exclusive` parameter when the virtual machine should be exported even if another copy of it already exists in the export domain (override). `storage_domain`:: The (export) storage domain to export the virtual machine to. `async_`:: Indicates if the export should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('directory', directory, str), ('discard_snapshots', discard_snapshots, bool), ('exclusive', exclusive, bool), ('filename', filename, str), ('host', host, types.Host), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, directory=directory, discard_snapshots=discard_snapshots, exclusive=exclusive, filename=filename, host=host, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def undo_snapshot( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Restores the virtual machine to the state it had before previewing the snapshot. See the <<services/vm/methods/preview_snapshot, preview_snapshot>> operation for details. This method supports the following parameters: `async_`:: Indicates if the undo snapshot action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'undosnapshot', None, headers, query, wait) def update( self, vm, async_=None, next_run=None, headers=None, query=None, wait=True, **kwargs ): """ Update the virtual machine in the system for the given virtual machine id. """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('async_', async_, bool), ('next_run', next_run, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if next_run is not None: next_run = Writer.render_boolean(next_run) query['next_run'] = next_run # Send the request and wait for the response: return self._internal_update(vm, headers, query, wait) def affinity_labels_service(self): """ List of scheduling labels assigned to this virtual machine. """ return AssignedAffinityLabelsService(self._connection, '%s/affinitylabels' % self._path) def applications_service(self): """ """ return VmApplicationsService(self._connection, '%s/applications' % self._path) def backups_service(self): """ List of backups of this virtual machine. """ return VmBackupsService(self._connection, '%s/backups' % self._path) def cdroms_service(self): """ """ return VmCdromsService(self._connection, '%s/cdroms' % self._path) def checkpoints_service(self): """ List of checkpoints of this virtual machine. """ return VmCheckpointsService(self._connection, '%s/checkpoints' % self._path) def disk_attachments_service(self): """ List of disks attached to this virtual machine. """ return DiskAttachmentsService(self._connection, '%s/diskattachments' % self._path) def graphics_consoles_service(self): """ """ return VmGraphicsConsolesService(self._connection, '%s/graphicsconsoles' % self._path) def host_devices_service(self): """ """ return VmHostDevicesService(self._connection, '%s/hostdevices' % self._path) def katello_errata_service(self): """ Reference to the service that can show the applicable errata available on the virtual machine. This information is taken from Katello. """ return KatelloErrataService(self._connection, '%s/katelloerrata' % self._path) def nics_service(self): """ """ return VmNicsService(self._connection, '%s/nics' % self._path) def numa_nodes_service(self): """ """ return VmNumaNodesService(self._connection, '%s/numanodes' % self._path) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def reported_devices_service(self): """ """ return VmReportedDevicesService(self._connection, '%s/reporteddevices' % self._path) def sessions_service(self): """ Reference to the service that provides information about virtual machine user sessions. """ return VmSessionsService(self._connection, '%s/sessions' % self._path) def snapshots_service(self): """ """ return SnapshotsService(self._connection, '%s/snapshots' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def tags_service(self): """ """ return AssignedTagsService(self._connection, '%s/tags' % self._path) def watchdogs_service(self): """ """ return VmWatchdogsService(self._connection, '%s/watchdogs' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'affinitylabels': return self.affinity_labels_service() if path.startswith('affinitylabels/'): return self.affinity_labels_service().service(path[15:]) if path == 'applications': return self.applications_service() if path.startswith('applications/'): return self.applications_service().service(path[13:]) if path == 'backups': return self.backups_service() if path.startswith('backups/'): return self.backups_service().service(path[8:]) if path == 'cdroms': return self.cdroms_service() if path.startswith('cdroms/'): return self.cdroms_service().service(path[7:]) if path == 'checkpoints': return self.checkpoints_service() if path.startswith('checkpoints/'): return self.checkpoints_service().service(path[12:]) if path == 'diskattachments': return self.disk_attachments_service() if path.startswith('diskattachments/'): return self.disk_attachments_service().service(path[16:]) if path == 'graphicsconsoles': return self.graphics_consoles_service() if path.startswith('graphicsconsoles/'): return self.graphics_consoles_service().service(path[17:]) if path == 'hostdevices': return self.host_devices_service() if path.startswith('hostdevices/'): return self.host_devices_service().service(path[12:]) if path == 'katelloerrata': return self.katello_errata_service() if path.startswith('katelloerrata/'): return self.katello_errata_service().service(path[14:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) if path == 'numanodes': return self.numa_nodes_service() if path.startswith('numanodes/'): return self.numa_nodes_service().service(path[10:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'reporteddevices': return self.reported_devices_service() if path.startswith('reporteddevices/'): return self.reported_devices_service().service(path[16:]) if path == 'sessions': return self.sessions_service() if path.startswith('sessions/'): return self.sessions_service().service(path[9:]) if path == 'snapshots': return self.snapshots_service() if path.startswith('snapshots/'): return self.snapshots_service().service(path[10:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) if path == 'watchdogs': return self.watchdogs_service() if path.startswith('watchdogs/'): return self.watchdogs_service().service(path[10:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmService, self).__init__(connection, path) self._affinity_labels_service = None self._applications_service = None self._backups_service = None self._cdroms_service = None self._checkpoints_service = None self._disk_attachments_service = None self._graphics_consoles_service = None self._host_devices_service = None self._katello_errata_service = None self._nics_service = None self._numa_nodes_service = None self._permissions_service = None self._reported_devices_service = None self._sessions_service = None self._snapshots_service = None self._statistics_service = None self._tags_service = None self._watchdogs_service = None
Creates a new service that will use the given connection and path.
#
def
auto_pin_cpu_and_numa_nodes(
self,
async_=None,
optimize_cpu_settings=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def auto_pin_cpu_and_numa_nodes( self, async_=None, optimize_cpu_settings=None, headers=None, query=None, wait=True, **kwargs ): """ Apply an automatic CPU and NUMA configuration on the VM. An example for a request: [source] ---- POST /ovirt-engine/api/vms/123/autopincpuandnumanodes ---- With a request body like this: [source,xml] ---- <action> <optimize_cpu_settings>true</optimize_cpu_settings> </action> ---- This method supports the following parameters: `optimize_cpu_settings`:: Specifies how the auto CPU and NUMA configuration is applied. If set to true, will adjust the CPU topology to fit the VM pinned host hardware. Otherwise, it will use the VM CPU topology. `async_`:: Indicates if the detach action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('optimize_cpu_settings', optimize_cpu_settings, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, optimize_cpu_settings=optimize_cpu_settings, ) # Send the request and wait for the response: return self._internal_action(action, 'autopincpuandnumanodes', None, headers, query, wait)
Apply an automatic CPU and NUMA configuration on the VM. An example for a request:
[source]
POST /ovirt-engine/api/vms/123/autopincpuandnumanodes
With a request body like this:
[source,xml]
This method supports the following parameters:
optimize_cpu_settings:: Specifies how the auto CPU and NUMA configuration is applied.
If set to true, will adjust the CPU topology to fit the VM pinned host hardware.
Otherwise, it will use the VM CPU topology.
async_:: Indicates if the detach action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def cancel_migration( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation stops any migration of a virtual machine to another physical host. [source] ---- POST /ovirt-engine/api/vms/123/cancelmigration ---- The cancel migration action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the migration should cancelled asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'cancelmigration', None, headers, query, wait)
This operation stops any migration of a virtual machine to another physical host.
[source]
POST /ovirt-engine/api/vms/123/cancelmigration
The cancel migration action does not take any action specific parameters;
therefore, the request body should contain an empty action:
[source,xml]
This method supports the following parameters:
async_:: Indicates if the migration should cancelled asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
clone(
self,
async_=None,
discard_snapshots=None,
storage_domain=None,
vm=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def clone( self, async_=None, discard_snapshots=None, storage_domain=None, vm=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the clone should be performed asynchronously. `discard_snapshots`:: Use the `discard_snapshots` parameter when the virtual machine should be clone with its snapshots collapsed. Default is true. `storage_domain`:: The storage domain on which the virtual machines disks will be copied to. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('discard_snapshots', discard_snapshots, bool), ('storage_domain', storage_domain, types.StorageDomain), ('vm', vm, types.Vm), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, discard_snapshots=discard_snapshots, storage_domain=storage_domain, vm=vm, ) # Send the request and wait for the response: return self._internal_action(action, 'clone', None, headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the clone should be performed asynchronously.
discard_snapshots:: Use the discard_snapshots parameter when the virtual machine should be clone with its
snapshots collapsed. Default is true.
storage_domain:: The storage domain on which the virtual machines disks will be copied to.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def commit_snapshot( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Permanently restores the virtual machine to the state of the previewed snapshot. See the <<services/vm/methods/preview_snapshot, preview_snapshot>> operation for details. This method supports the following parameters: `async_`:: Indicates if the snapshots should be committed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'commitsnapshot', None, headers, query, wait)
Permanently restores the virtual machine to the state of the previewed snapshot.
See the <
This method supports the following parameters:
async_:: Indicates if the snapshots should be committed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def detach( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Detaches a virtual machine from a pool. [source] ---- POST /ovirt-engine/api/vms/123/detach ---- The detach action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the detach action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'detach', None, headers, query, wait)
Detaches a virtual machine from a pool.
[source]
POST /ovirt-engine/api/vms/123/detach
The detach action does not take any action specific parameters; therefore, the request body should contain an
empty action:
[source,xml]
This method supports the following parameters:
async_:: Indicates if the detach action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
export(
self,
async_=None,
discard_snapshots=None,
exclusive=None,
storage_domain=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def export( self, async_=None, discard_snapshots=None, exclusive=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports the virtual machine. A virtual machine can be exported to an export domain. For example, to export virtual machine `123` to the export domain `myexport`: [source] ---- POST /ovirt-engine/api/vms/123/export ---- With a request body like this: [source,xml] ---- <action> <storage_domain> <name>myexport</name> </storage_domain> <exclusive>true</exclusive> <discard_snapshots>true</discard_snapshots> </action> ---- Since version 4.2 of the engine it is also possible to export a virtual machine as a virtual appliance (OVA). For example, to export virtual machine `123` as an OVA file named `myvm.ova` that is placed in the directory `/home/ovirt/` on host `myhost`: [source] ---- POST /ovirt-engine/api/vms/123/export ---- With a request body like this: [source,xml] ---- <action> <host> <name>myhost</name> </host> <directory>/home/ovirt</directory> <filename>myvm.ova</filename> </action> ---- NOTE: Confirm that the export operation has completed before attempting any actions on the export domain. This method supports the following parameters: `discard_snapshots`:: Use the `discard_snapshots` parameter when the virtual machine should be exported with all of its snapshots collapsed. `exclusive`:: Use the `exclusive` parameter when the virtual machine should be exported even if another copy of it already exists in the export domain (override). `storage_domain`:: The (export) storage domain to export the virtual machine to. `async_`:: Indicates if the export should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('discard_snapshots', discard_snapshots, bool), ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, discard_snapshots=discard_snapshots, exclusive=exclusive, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait)
Exports the virtual machine.
A virtual machine can be exported to an export domain.
For example, to export virtual machine 123 to the export domain myexport:
[source]
POST /ovirt-engine/api/vms/123/export
With a request body like this:
[source,xml]
Since version 4.2 of the engine it is also possible to export a virtual machine as a virtual appliance (OVA).
For example, to export virtual machine 123 as an OVA file named myvm.ova that is placed in the directory /home/ovirt/ on host myhost:
[source]
POST /ovirt-engine/api/vms/123/export
With a request body like this:
[source,xml]
NOTE: Confirm that the export operation has completed before attempting any actions on the export domain.
This method supports the following parameters:
discard_snapshots:: Use the discard_snapshots parameter when the virtual machine should be exported with all of its
snapshots collapsed.
exclusive:: Use the exclusive parameter when the virtual machine should be exported even if another copy of
it already exists in the export domain (override).
storage_domain:: The (export) storage domain to export the virtual machine to.
async_:: Indicates if the export should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def freeze_filesystems( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Freezes virtual machine file systems. This operation freezes a virtual machine's file systems using the QEMU guest agent when taking a live snapshot of a running virtual machine. Normally, this is done automatically by the manager, but this must be executed manually with the API for virtual machines using OpenStack Volume (Cinder) disks. Example: [source] ---- POST /ovirt-engine/api/vms/123/freezefilesystems ---- [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the freeze should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'freezefilesystems', None, headers, query, wait)
Freezes virtual machine file systems. This operation freezes a virtual machine's file systems using the QEMU guest agent when taking a live snapshot of a running virtual machine. Normally, this is done automatically by the manager, but this must be executed manually with the API for virtual machines using OpenStack Volume (Cinder) disks. Example:
[source]
POST /ovirt-engine/api/vms/123/freezefilesystems
[source,xml]
This method supports the following parameters:
async_:: Indicates if the freeze should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
get(
self,
all_content=None,
filter=None,
follow=None,
next_run=None,
ovf_as_ova=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def get( self, all_content=None, filter=None, follow=None, next_run=None, ovf_as_ova=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the virtual machine. This method supports the following parameters: `next_run`:: Indicates if the returned result describes the virtual machine as it is currently running or if describes the virtual machine with the modifications that have already been performed but that will only come into effect when the virtual machine is restarted. By default the value is `false`. If the parameter is included in the request, but without a value, it is assumed that the value is `true`. The the following request: [source] ---- GET /vms/{vm:id};next_run ---- Is equivalent to using the value `true`: [source] ---- GET /vms/{vm:id};next_run=true ---- `all_content`:: Indicates if all of the attributes of the virtual machine should be included in the response. By default the following attributes are excluded: - `console` - `initialization.configuration.data` - The OVF document describing the virtual machine. - `rng_source` - `soundcard` - `virtio_scsi` For example, to retrieve the complete representation of the virtual machine '123': .... GET /ovirt-engine/api/vms/123?all_content=true .... NOTE: These attributes are not included by default as they reduce performance. These attributes are seldom used and require additional queries to the database. Only use this parameter when required as it will reduce performance. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `ovf_as_ova`:: Indicates if the results should expose the OVF as it appears in OVA files of that VM. The OVF document describing the virtual machine. This parameter will work only when all_content=True is set. The OVF will be presented in `initialization.configuration.data`. For example: [source] ---- GET /vms/{vm:id}?all_content=true&ovf_as_ova=true ---- `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('filter', filter, bool), ('follow', follow, str), ('next_run', next_run, bool), ('ovf_as_ova', ovf_as_ova, bool), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if next_run is not None: next_run = Writer.render_boolean(next_run) query['next_run'] = next_run if ovf_as_ova is not None: ovf_as_ova = Writer.render_boolean(ovf_as_ova) query['ovf_as_ova'] = ovf_as_ova # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the description of the virtual machine.
This method supports the following parameters:
next_run:: Indicates if the returned result describes the virtual machine as it is currently running or if describes
the virtual machine with the modifications that have already been performed but that will only come into
effect when the virtual machine is restarted. By default the value is false.
If the parameter is included in the request, but without a value, it is assumed that the value is true. The
the following request:
[source]
GET /vms/{vm:id};next_run
Is equivalent to using the value true:
[source]
GET /vms/{vm:id};next_run=true
all_content:: Indicates if all of the attributes of the virtual machine should be included in the response.
By default the following attributes are excluded:
consoleinitialization.configuration.data- The OVF document describing the virtual machine.rng_sourcesoundcardvirtio_scsiFor example, to retrieve the complete representation of the virtual machine '123': .... GET /ovirt-engine/api/vms/123?all_content=true .... NOTE: These attributes are not included by default as they reduce performance. These attributes are seldom used and require additional queries to the database. Only use this parameter when required as it will reduce performance.
filter:: Indicates if the results should be filtered according to the permissions of the user.
ovf_as_ova:: Indicates if the results should expose the OVF as it appears in OVA files of that VM. The OVF document
describing the virtual machine. This parameter will work only when all_content=True is set.
The OVF will be presented in initialization.configuration.data.
For example:
[source]
GET /vms/{vm:id}?all_content=true&ovf_as_ova=true
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def logon( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Initiates the automatic user logon to access a virtual machine from an external console. This action requires the `ovirt-guest-agent-gdm-plugin` and the `ovirt-guest-agent-pam-module` packages to be installed and the `ovirt-guest-agent` service to be running on the virtual machine. Users require the appropriate user permissions for the virtual machine in order to access the virtual machine from an external console. For example: [source] ---- POST /ovirt-engine/api/vms/123/logon ---- Request body: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the logon should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'logon', None, headers, query, wait)
Initiates the automatic user logon to access a virtual machine from an external console.
This action requires the ovirt-guest-agent-gdm-plugin and the ovirt-guest-agent-pam-module packages to be
installed and the ovirt-guest-agent service to be running on the virtual machine.
Users require the appropriate user permissions for the virtual machine in order to access the virtual machine
from an external console.
For example:
[source]
POST /ovirt-engine/api/vms/123/logon
Request body:
[source,xml]
This method supports the following parameters:
async_:: Indicates if the logon should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
maintenance(
self,
async_=None,
maintenance_enabled=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def maintenance( self, async_=None, maintenance_enabled=None, headers=None, query=None, wait=True, **kwargs ): """ Sets the global maintenance mode on the hosted engine virtual machine. This action has no effect on other virtual machines. Example: [source] ---- POST /ovirt-engine/api/vms/123/maintenance ---- [source,xml] ---- <action> <maintenance_enabled>true<maintenance_enabled/> </action> ---- This method supports the following parameters: `maintenance_enabled`:: Indicates if global maintenance should be enabled or disabled. `async_`:: Indicates if the global maintenance action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('maintenance_enabled', maintenance_enabled, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, maintenance_enabled=maintenance_enabled, ) # Send the request and wait for the response: return self._internal_action(action, 'maintenance', None, headers, query, wait)
Sets the global maintenance mode on the hosted engine virtual machine. This action has no effect on other virtual machines. Example:
[source]
POST /ovirt-engine/api/vms/123/maintenance
[source,xml]
This method supports the following parameters:
maintenance_enabled:: Indicates if global maintenance should be enabled or disabled.
async_:: Indicates if the global maintenance action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
migrate(
self,
async_=None,
cluster=None,
force=None,
host=None,
migrate_vms_in_affinity_closure=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def migrate( self, async_=None, cluster=None, force=None, host=None, migrate_vms_in_affinity_closure=None, headers=None, query=None, wait=True, **kwargs ): """ Migrates a virtual machine to another physical host. Example: [source] ---- POST /ovirt-engine/api/vms/123/migrate ---- To specify a specific host to migrate the virtual machine to: [source,xml] ---- <action> <host id="2ab5e1da-b726-4274-bbf7-0a42b16a0fc3"/> </action> ---- This method supports the following parameters: `cluster`:: Specifies the cluster the virtual machine should migrate to. This is an optional parameter. By default, the virtual machine is migrated to another host within the same cluster. WARNING: Live migration to another cluster is not supported. Strongly consider the target cluster's hardware architecture and network architecture before attempting a migration. `force`:: Specifies that the virtual machine should migrate even if the virtual machine is defined as non-migratable. This is an optional parameter. By default, it is set to `false`. `host`:: Specifies a specific host that the virtual machine should migrate to. This is an optional parameter. By default, the {engine-name} automatically selects a default host for migration within the same cluster. If an API user requires a specific host, the user can specify the host with either an `id` or `name` parameter. `migrate_vms_in_affinity_closure`:: Migrate also all other virtual machines in positive enforcing affinity groups with this virtual machine, that are running on the same host. The default value is `false`. `async_`:: Indicates if the migration should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('force', force, bool), ('host', host, types.Host), ('migrate_vms_in_affinity_closure', migrate_vms_in_affinity_closure, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, cluster=cluster, force=force, host=host, migrate_vms_in_affinity_closure=migrate_vms_in_affinity_closure, ) # Send the request and wait for the response: return self._internal_action(action, 'migrate', None, headers, query, wait)
Migrates a virtual machine to another physical host. Example:
[source]
POST /ovirt-engine/api/vms/123/migrate
To specify a specific host to migrate the virtual machine to:
[source,xml]
This method supports the following parameters:
cluster:: Specifies the cluster the virtual machine should migrate to. This is an optional parameter. By default, the
virtual machine is migrated to another host within the same cluster.
WARNING: Live migration to another cluster is not supported. Strongly consider the target cluster's hardware
architecture and network architecture before attempting a migration.
force:: Specifies that the virtual machine should migrate even if the virtual machine is defined as non-migratable.
This is an optional parameter. By default, it is set to false.
host:: Specifies a specific host that the virtual machine should migrate to. This is an optional parameter. By default,
the {engine-name} automatically selects a default host for migration within the same cluster. If an API user
requires a specific host, the user can specify the host with either an id or name parameter.
migrate_vms_in_affinity_closure:: Migrate also all other virtual machines in positive enforcing affinity groups with this virtual machine,
that are running on the same host.
The default value is false.
async_:: Indicates if the migration should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
preview_snapshot(
self,
async_=None,
disks=None,
lease=None,
restore_memory=None,
snapshot=None,
vm=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def preview_snapshot( self, async_=None, disks=None, lease=None, restore_memory=None, snapshot=None, vm=None, headers=None, query=None, wait=True, **kwargs ): """ Temporarily restores the virtual machine to the state of a snapshot. The snapshot is indicated with the `snapshot.id` parameter. It is restored temporarily, so that the content can be inspected. Once that inspection is finished, the state of the virtual machine can be made permanent, using the <<services/vm/methods/commit_snapshot, commit_snapshot>> method, or discarded using the <<services/vm/methods/undo_snapshot, undo_snapshot>> method. This method supports the following parameters: `disks`:: Specify the disks included in the snapshot's preview. For each disk parameter, it is also required to specify its `image_id`. For example, to preview a snapshot with identifier `456` which includes a disk with identifier `111` and its `image_id` as `222`, send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/previewsnapshot ---- Request body: [source,xml] ---- <action> <disks> <disk id="111"> <image_id>222</image_id> </disk> </disks> <snapshot id="456"/> </action> ---- `lease`:: Specify the lease storage domain ID to use in the preview of the snapshot. If lease parameter is not passed, then the previewed snapshot lease storage domain will be used. If lease parameter is passed with empty storage domain parameter, then no lease will be used for the snapshot preview. If lease parameter is passed with storage domain parameter then the storage domain ID can be only one of the leases domain IDs that belongs to one of the virtual machine snapshots. This is an optional parameter, set by default to `null` `async_`:: Indicates if the preview should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('disks', disks, list), ('lease', lease, types.StorageDomainLease), ('restore_memory', restore_memory, bool), ('snapshot', snapshot, types.Snapshot), ('vm', vm, types.Vm), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, disks=disks, lease=lease, restore_memory=restore_memory, snapshot=snapshot, vm=vm, ) # Send the request and wait for the response: return self._internal_action(action, 'previewsnapshot', None, headers, query, wait)
Temporarily restores the virtual machine to the state of a snapshot.
The snapshot is indicated with the snapshot.id parameter. It is restored temporarily, so that the content can
be inspected. Once that inspection is finished, the state of the virtual machine can be made permanent, using the
<
This method supports the following parameters:
disks:: Specify the disks included in the snapshot's preview.
For each disk parameter, it is also required to specify its image_id.
For example, to preview a snapshot with identifier 456 which includes a disk with identifier 111 and its
image_id as 222, send a request like this:
[source]
POST /ovirt-engine/api/vms/123/previewsnapshot
Request body:
[source,xml]
lease:: Specify the lease storage domain ID to use in the preview of the snapshot.
If lease parameter is not passed, then the previewed snapshot lease storage domain will be used.
If lease parameter is passed with empty storage domain parameter, then no lease will be used
for the snapshot preview.
If lease parameter is passed with storage domain parameter then the storage domain ID can be
only one of the leases domain IDs that belongs to one of the virtual machine snapshots.
This is an optional parameter, set by default to null
async_:: Indicates if the preview should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def reboot( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Sends a reboot request to a virtual machine. For example: [source] ---- POST /ovirt-engine/api/vms/123/reboot ---- The reboot action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- To reboot the VM even if a backup is running for it, the action should include the 'force' element. For example, to force reboot virtual machine `123`: ---- POST /ovirt-engine/api/vms/123/reboot ---- [source,xml] ---- <action> <force>true</force> </action> ---- This method supports the following parameters: `force`:: Indicates if the VM should be forcibly rebooted even if a backup is running for it. `async_`:: Indicates if the reboot should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'reboot', None, headers, query, wait)
Sends a reboot request to a virtual machine. For example:
[source]
POST /ovirt-engine/api/vms/123/reboot
The reboot action does not take any action specific parameters; therefore, the request body should contain an
empty action:
[source,xml]
To reboot the VM even if a backup is running for it, the action should include the 'force' element.
For example, to force reboot virtual machine 123:
POST /ovirt-engine/api/vms/123/reboot
[source,xml]
This method supports the following parameters:
force:: Indicates if the VM should be forcibly rebooted even
if a backup is running for it.
async_:: Indicates if the reboot should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
remove(
self,
async_=None,
detach_only=None,
force=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def remove( self, async_=None, detach_only=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the virtual machine, including the virtual disks attached to it. For example, to remove the virtual machine with identifier `123`: [source] ---- DELETE /ovirt-engine/api/vms/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `detach_only`:: Indicates if the attached virtual disks should be detached first and preserved instead of being removed. `force`:: Indicates if the virtual machine should be forcibly removed. Locked virtual machines and virtual machines with locked disk images cannot be removed without this flag set to true. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('detach_only', detach_only, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if detach_only is not None: detach_only = Writer.render_boolean(detach_only) query['detach_only'] = detach_only if force is not None: force = Writer.render_boolean(force) query['force'] = force # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the virtual machine, including the virtual disks attached to it.
For example, to remove the virtual machine with identifier 123:
[source]
DELETE /ovirt-engine/api/vms/123
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
detach_only:: Indicates if the attached virtual disks should be detached first and preserved instead of being removed.
force:: Indicates if the virtual machine should be forcibly removed.
Locked virtual machines and virtual machines with locked disk images
cannot be removed without this flag set to true.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def reorder_mac_addresses( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reordermacaddresses', None, headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def reset( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Sends a reset request to a virtual machine. For example: [source] ---- POST /ovirt-engine/api/vms/123/reset ---- The reset action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the reset should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reset', None, headers, query, wait)
Sends a reset request to a virtual machine. For example:
[source]
POST /ovirt-engine/api/vms/123/reset
The reset action does not take any action specific parameters; therefore, the request body should contain an
empty action:
[source,xml]
This method supports the following parameters:
async_:: Indicates if the reset should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
shutdown(
self,
async_=None,
force=None,
reason=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def shutdown( self, async_=None, force=None, reason=None, headers=None, query=None, wait=True, **kwargs ): """ This operation sends a shutdown request to a virtual machine. For example: [source] ---- POST /ovirt-engine/api/vms/123/shutdown ---- The shutdown action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- To shutdown the VM even if a backup is running for it, the action should include the 'force' element. For example, to force shutdown virtual machine `123`: ---- POST /ovirt-engine/api/vms/123/shutdown ---- [source,xml] ---- <action> <force>true</force> </action> ---- This method supports the following parameters: `force`:: Indicates if the VM should be forcibly shutdown even if a backup is running for it. `async_`:: Indicates if the shutdown should be performed asynchronously. `reason`:: The reason the virtual machine was stopped. Optionally set by user when shutting down the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('reason', reason, str), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, reason=reason, ) # Send the request and wait for the response: return self._internal_action(action, 'shutdown', None, headers, query, wait)
This operation sends a shutdown request to a virtual machine. For example:
[source]
POST /ovirt-engine/api/vms/123/shutdown
The shutdown action does not take any action specific parameters;
therefore, the request body should contain an empty action:
[source,xml]
To shutdown the VM even if a backup is running for it, the action should include the 'force' element.
For example, to force shutdown virtual machine 123:
POST /ovirt-engine/api/vms/123/shutdown
[source,xml]
This method supports the following parameters:
force:: Indicates if the VM should be forcibly shutdown even
if a backup is running for it.
async_:: Indicates if the shutdown should be performed asynchronously.
reason:: The reason the virtual machine was stopped.
Optionally set by user when shutting down the virtual machine.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
start(
self,
async_=None,
authorized_key=None,
filter=None,
pause=None,
use_cloud_init=None,
use_ignition=None,
use_initialization=None,
use_sysprep=None,
vm=None,
volatile=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def start( self, async_=None, authorized_key=None, filter=None, pause=None, use_cloud_init=None, use_ignition=None, use_initialization=None, use_sysprep=None, vm=None, volatile=None, headers=None, query=None, wait=True, **kwargs ): """ Starts the virtual machine. If the virtual environment is complete and the virtual machine contains all necessary components to function, it can be started. This example starts the virtual machine: [source] ---- POST /ovirt-engine/api/vms/123/start ---- With a request body: [source,xml] ---- <action/> ---- This method supports the following parameters: `pause`:: If set to `true`, start the virtual machine in paused mode. The default is `false`. `vm`:: The definition of the virtual machine for this specific run. For example: [source,xml] ---- <action> <vm> <os> <boot> <devices> <device>cdrom</device> </devices> </boot> </os> </vm> </action> ---- This will set the boot device to the CDROM only for this specific start. After the virtual machine is powered off, this definition will be reverted. `use_cloud_init`:: If set to `true`, the initialization type is set to _cloud-init_. The default value is `false`. See https://cloudinit.readthedocs.io/en/latest[this] for details. `use_sysprep`:: If set to `true`, the initialization type is set to _Sysprep_. The default value is `false`. See https://en.wikipedia.org/wiki/Sysprep[this] for details. `use_ignition`:: If set to `true`, the initialization type is set to _Ignition_. The default value is `false`. See https://coreos.com/ignition/docs/latest/[this] for details. `use_initialization`:: If set to `true`, the initialization type is set by the VM's OS. Windows will set to _Sysprep_, Linux to _cloud-init_ and RedHat CoreOS to _Ignition_. If any of the initialization-types are explicitly set (useCloudInit, useSysprep or useIgnition), they will be prioritized and this flag will be ignored. The default value is `false`. `async_`:: Indicates if the start action should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `volatile`:: Indicates that this run configuration will be discarded even in the case of guest-initiated reboot. The default value is `false`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('authorized_key', authorized_key, types.AuthorizedKey), ('filter', filter, bool), ('pause', pause, bool), ('use_cloud_init', use_cloud_init, bool), ('use_ignition', use_ignition, bool), ('use_initialization', use_initialization, bool), ('use_sysprep', use_sysprep, bool), ('vm', vm, types.Vm), ('volatile', volatile, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, authorized_key=authorized_key, filter=filter, pause=pause, use_cloud_init=use_cloud_init, use_ignition=use_ignition, use_initialization=use_initialization, use_sysprep=use_sysprep, vm=vm, volatile=volatile, ) # Send the request and wait for the response: return self._internal_action(action, 'start', None, headers, query, wait)
Starts the virtual machine. If the virtual environment is complete and the virtual machine contains all necessary components to function, it can be started. This example starts the virtual machine:
[source]
POST /ovirt-engine/api/vms/123/start
With a request body:
[source,xml]
This method supports the following parameters:
pause:: If set to true, start the virtual machine in paused mode. The default is false.
vm:: The definition of the virtual machine for this specific run.
For example:
[source,xml]
This will set the boot device to the CDROM only for this specific start. After the virtual machine is powered off, this definition will be reverted.
use_cloud_init:: If set to true, the initialization type is set to _cloud-init_. The default value is false.
See https://cloudinit.readthedocs.io/en/latest[this] for details.
use_sysprep:: If set to true, the initialization type is set to _Sysprep_. The default value is false.
See https://en.wikipedia.org/wiki/Sysprep[this] for details.
use_ignition:: If set to true, the initialization type is set to _Ignition_. The default value is false.
See https://coreos.com/ignition/docs/latest/[this] for details.
use_initialization:: If set to true, the initialization type is set by the VM's OS.
Windows will set to _Sysprep_, Linux to _cloud-init_ and RedHat CoreOS to _Ignition_.
If any of the initialization-types are explicitly set (useCloudInit, useSysprep or useIgnition),
they will be prioritized and this flag will be ignored.
The default value is false.
async_:: Indicates if the start action should be performed asynchronously.
filter:: Indicates if the results should be filtered according to the permissions of the user.
volatile:: Indicates that this run configuration will be discarded even in the case of guest-initiated reboot.
The default value is false.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
stop(
self,
async_=None,
force=None,
reason=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def stop( self, async_=None, force=None, reason=None, headers=None, query=None, wait=True, **kwargs ): """ This operation forces a virtual machine to power-off. For example: [source] ---- POST /ovirt-engine/api/vms/123/stop ---- The stop action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- To stop the VM even if a backup is running for it, the action should include the 'force' element. For example, to force stop virtual machine `123`: ---- POST /ovirt-engine/api/vms/123/stop ---- [source,xml] ---- <action> <force>true</force> </action> ---- This method supports the following parameters: `force`:: Indicates if the VM should be forcibly stop even if a backup is running for it. `async_`:: Indicates if the stop action should be performed asynchronously. `reason`:: The reason the virtual machine was stopped. Optionally set by user when shutting down the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('reason', reason, str), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, reason=reason, ) # Send the request and wait for the response: return self._internal_action(action, 'stop', None, headers, query, wait)
This operation forces a virtual machine to power-off. For example:
[source]
POST /ovirt-engine/api/vms/123/stop
The stop action does not take any action specific parameters;
therefore, the request body should contain an empty action:
[source,xml]
To stop the VM even if a backup is running for it, the action should include the 'force' element.
For example, to force stop virtual machine 123:
POST /ovirt-engine/api/vms/123/stop
[source,xml]
This method supports the following parameters:
force:: Indicates if the VM should be forcibly stop even
if a backup is running for it.
async_:: Indicates if the stop action should be performed asynchronously.
reason:: The reason the virtual machine was stopped.
Optionally set by user when shutting down the virtual machine.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def suspend( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation saves the virtual machine state to disk and stops it. Start a suspended virtual machine and restore the virtual machine state with the start action. For example: [source] ---- POST /ovirt-engine/api/vms/123/suspend ---- The suspend action does not take any action specific parameters; therefore, the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the suspend action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'suspend', None, headers, query, wait)
This operation saves the virtual machine state to disk and stops it. Start a suspended virtual machine and restore the virtual machine state with the start action. For example:
[source]
POST /ovirt-engine/api/vms/123/suspend
The suspend action does not take any action specific parameters;
therefore, the request body should contain an empty action:
[source,xml]
This method supports the following parameters:
async_:: Indicates if the suspend action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def thaw_filesystems( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Thaws virtual machine file systems. This operation thaws a virtual machine's file systems using the QEMU guest agent when taking a live snapshot of a running virtual machine. Normally, this is done automatically by the manager, but this must be executed manually with the API for virtual machines using OpenStack Volume (Cinder) disks. Example: [source] ---- POST /api/vms/123/thawfilesystems ---- [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the thaw file systems action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'thawfilesystems', None, headers, query, wait)
Thaws virtual machine file systems. This operation thaws a virtual machine's file systems using the QEMU guest agent when taking a live snapshot of a running virtual machine. Normally, this is done automatically by the manager, but this must be executed manually with the API for virtual machines using OpenStack Volume (Cinder) disks. Example:
[source]
POST /api/vms/123/thawfilesystems
[source,xml]
This method supports the following parameters:
async_:: Indicates if the thaw file systems action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def ticket( self, async_=None, ticket=None, headers=None, query=None, wait=True, **kwargs ): """ Generates a time-sensitive authentication token for accessing a virtual machine's display. For example: [source] ---- POST /ovirt-engine/api/vms/123/ticket ---- The client-provided action optionally includes a desired ticket value and/or an expiry time in seconds. The response specifies the actual ticket value and expiry used. [source,xml] ---- <action> <ticket> <value>abcd12345</value> <expiry>120</expiry> </ticket> </action> ---- [IMPORTANT] ==== If the virtual machine is configured to support only one graphics protocol then the generated authentication token will be valid for that protocol. But if the virtual machine is configured to support multiple protocols, VNC and SPICE, then the authentication token will only be valid for the SPICE protocol. In order to obtain an authentication token for a specific protocol, for example for VNC, use the `ticket` method of the <<services/vm_graphics_console, service>>, which manages the graphics consoles of the virtual machine, by sending a request: [source] ---- POST /ovirt-engine/api/vms/123/graphicsconsoles/456/ticket ---- ==== This method supports the following parameters: `async_`:: Indicates if the generation of the ticket should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('ticket', ticket, types.Ticket), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ticket=ticket, ) # Send the request and wait for the response: return self._internal_action(action, 'ticket', 'ticket', headers, query, wait)
Generates a time-sensitive authentication token for accessing a virtual machine's display. For example:
[source]
POST /ovirt-engine/api/vms/123/ticket
The client-provided action optionally includes a desired ticket value and/or an expiry time in seconds. The response specifies the actual ticket value and expiry used.
[source,xml]
[IMPORTANT]
If the virtual machine is configured to support only one graphics protocol
then the generated authentication token will be valid for that protocol.
But if the virtual machine is configured to support multiple protocols,
VNC and SPICE, then the authentication token will only be valid for
the SPICE protocol.
In order to obtain an authentication token for a specific protocol, for
example for VNC, use the ticket method of the <
[source]
POST /ovirt-engine/api/vms/123/graphicsconsoles/456/ticket
====
This method supports the following parameters:
async_:: Indicates if the generation of the ticket should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
export_to_export_domain(
self,
async_=None,
discard_snapshots=None,
exclusive=None,
storage_domain=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def export_to_export_domain( self, async_=None, discard_snapshots=None, exclusive=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a virtual machine to an export domain. This method supports the following parameters: `discard_snapshots`:: Use the `discard_snapshots` parameter when the virtual machine should be exported with all of its snapshots collapsed. `exclusive`:: Use the `exclusive` parameter when the virtual machine should be exported even if another copy of it already exists in the export domain (override). `storage_domain`:: The (export) storage domain to export the virtual machine to. `async_`:: Indicates if the export should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('discard_snapshots', discard_snapshots, bool), ('exclusive', exclusive, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, discard_snapshots=discard_snapshots, exclusive=exclusive, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait)
Exports a virtual machine to an export domain.
This method supports the following parameters:
discard_snapshots:: Use the discard_snapshots parameter when the virtual machine should be exported with all of its
snapshots collapsed.
exclusive:: Use the exclusive parameter when the virtual machine should be exported even if another copy of
it already exists in the export domain (override).
storage_domain:: The (export) storage domain to export the virtual machine to.
async_:: Indicates if the export should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
export_to_path_on_host(
self,
async_=None,
directory=None,
discard_snapshots=None,
exclusive=None,
filename=None,
host=None,
storage_domain=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def export_to_path_on_host( self, async_=None, directory=None, discard_snapshots=None, exclusive=None, filename=None, host=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a virtual machine as an OVA file to a given path on a specified host. This method supports the following parameters: `host`:: The host to generate the OVA file on. `directory`:: An absolute path of a directory on the host to generate the OVA file in. `filename`:: The name of the OVA file. This is an optional parameter, if it is not specified then the name of OVA file is determined according to the name of the virtual machine. It will conform the following pattern: "<virtual machine name>.ova". `discard_snapshots`:: Use the `discard_snapshots` parameter when the virtual machine should be exported with all of its snapshots collapsed. `exclusive`:: Use the `exclusive` parameter when the virtual machine should be exported even if another copy of it already exists in the export domain (override). `storage_domain`:: The (export) storage domain to export the virtual machine to. `async_`:: Indicates if the export should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('directory', directory, str), ('discard_snapshots', discard_snapshots, bool), ('exclusive', exclusive, bool), ('filename', filename, str), ('host', host, types.Host), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, directory=directory, discard_snapshots=discard_snapshots, exclusive=exclusive, filename=filename, host=host, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait)
Exports a virtual machine as an OVA file to a given path on a specified host.
This method supports the following parameters:
host:: The host to generate the OVA file on.
directory:: An absolute path of a directory on the host to generate the OVA file in.
filename:: The name of the OVA file.
This is an optional parameter, if it is not specified then the name of OVA file is determined according
to the name of the virtual machine. It will conform the following pattern: "
discard_snapshots:: Use the discard_snapshots parameter when the virtual machine should be exported with all of its
snapshots collapsed.
exclusive:: Use the exclusive parameter when the virtual machine should be exported even if another copy of
it already exists in the export domain (override).
storage_domain:: The (export) storage domain to export the virtual machine to.
async_:: Indicates if the export should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def undo_snapshot( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Restores the virtual machine to the state it had before previewing the snapshot. See the <<services/vm/methods/preview_snapshot, preview_snapshot>> operation for details. This method supports the following parameters: `async_`:: Indicates if the undo snapshot action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'undosnapshot', None, headers, query, wait)
Restores the virtual machine to the state it had before previewing the snapshot.
See the <
This method supports the following parameters:
async_:: Indicates if the undo snapshot action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
update(
self,
vm,
async_=None,
next_run=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def update( self, vm, async_=None, next_run=None, headers=None, query=None, wait=True, **kwargs ): """ Update the virtual machine in the system for the given virtual machine id. """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('async_', async_, bool), ('next_run', next_run, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ if next_run is not None: next_run = Writer.render_boolean(next_run) query['next_run'] = next_run # Send the request and wait for the response: return self._internal_update(vm, headers, query, wait)
Update the virtual machine in the system for the given virtual machine id.
View Source
def affinity_labels_service(self): """ List of scheduling labels assigned to this virtual machine. """ return AssignedAffinityLabelsService(self._connection, '%s/affinitylabels' % self._path)
List of scheduling labels assigned to this virtual machine.
View Source
def applications_service(self): """ """ return VmApplicationsService(self._connection, '%s/applications' % self._path)
View Source
def backups_service(self): """ List of backups of this virtual machine. """ return VmBackupsService(self._connection, '%s/backups' % self._path)
List of backups of this virtual machine.
View Source
def cdroms_service(self): """ """ return VmCdromsService(self._connection, '%s/cdroms' % self._path)
View Source
def checkpoints_service(self): """ List of checkpoints of this virtual machine. """ return VmCheckpointsService(self._connection, '%s/checkpoints' % self._path)
List of checkpoints of this virtual machine.
View Source
def disk_attachments_service(self): """ List of disks attached to this virtual machine. """ return DiskAttachmentsService(self._connection, '%s/diskattachments' % self._path)
List of disks attached to this virtual machine.
View Source
def graphics_consoles_service(self): """ """ return VmGraphicsConsolesService(self._connection, '%s/graphicsconsoles' % self._path)
View Source
def host_devices_service(self): """ """ return VmHostDevicesService(self._connection, '%s/hostdevices' % self._path)
View Source
def katello_errata_service(self): """ Reference to the service that can show the applicable errata available on the virtual machine. This information is taken from Katello. """ return KatelloErrataService(self._connection, '%s/katelloerrata' % self._path)
Reference to the service that can show the applicable errata available on the virtual machine. This information is taken from Katello.
View Source
def nics_service(self): """ """ return VmNicsService(self._connection, '%s/nics' % self._path)
View Source
def numa_nodes_service(self): """ """ return VmNumaNodesService(self._connection, '%s/numanodes' % self._path)
View Source
def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
View Source
def reported_devices_service(self): """ """ return VmReportedDevicesService(self._connection, '%s/reporteddevices' % self._path)
View Source
def sessions_service(self): """ Reference to the service that provides information about virtual machine user sessions. """ return VmSessionsService(self._connection, '%s/sessions' % self._path)
Reference to the service that provides information about virtual machine user sessions.
View Source
def snapshots_service(self): """ """ return SnapshotsService(self._connection, '%s/snapshots' % self._path)
View Source
def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path)
View Source
def watchdogs_service(self): """ """ return VmWatchdogsService(self._connection, '%s/watchdogs' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'affinitylabels': return self.affinity_labels_service() if path.startswith('affinitylabels/'): return self.affinity_labels_service().service(path[15:]) if path == 'applications': return self.applications_service() if path.startswith('applications/'): return self.applications_service().service(path[13:]) if path == 'backups': return self.backups_service() if path.startswith('backups/'): return self.backups_service().service(path[8:]) if path == 'cdroms': return self.cdroms_service() if path.startswith('cdroms/'): return self.cdroms_service().service(path[7:]) if path == 'checkpoints': return self.checkpoints_service() if path.startswith('checkpoints/'): return self.checkpoints_service().service(path[12:]) if path == 'diskattachments': return self.disk_attachments_service() if path.startswith('diskattachments/'): return self.disk_attachments_service().service(path[16:]) if path == 'graphicsconsoles': return self.graphics_consoles_service() if path.startswith('graphicsconsoles/'): return self.graphics_consoles_service().service(path[17:]) if path == 'hostdevices': return self.host_devices_service() if path.startswith('hostdevices/'): return self.host_devices_service().service(path[12:]) if path == 'katelloerrata': return self.katello_errata_service() if path.startswith('katelloerrata/'): return self.katello_errata_service().service(path[14:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) if path == 'numanodes': return self.numa_nodes_service() if path.startswith('numanodes/'): return self.numa_nodes_service().service(path[10:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'reporteddevices': return self.reported_devices_service() if path.startswith('reporteddevices/'): return self.reported_devices_service().service(path[16:]) if path == 'sessions': return self.sessions_service() if path.startswith('sessions/'): return self.sessions_service().service(path[9:]) if path == 'snapshots': return self.snapshots_service() if path.startswith('snapshots/'): return self.snapshots_service().service(path[10:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) if path == 'watchdogs': return self.watchdogs_service() if path.startswith('watchdogs/'): return self.watchdogs_service().service(path[10:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmApplicationService(Service): """ A service that provides information about an application installed in a virtual machine. """ def __init__(self, connection, path): super(VmApplicationService, self).__init__(connection, path) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about the application. This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmApplicationService:%s' % self._path
A service that provides information about an application installed in a virtual machine.
View Source
def __init__(self, connection, path): super(VmApplicationService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about the application. This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the information about the application.
This method supports the following parameters:
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmApplicationsService(Service): """ A service that provides information about applications installed in a virtual machine. """ def __init__(self, connection, path): super(VmApplicationsService, self).__init__(connection, path) self._application_service = None def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns a list of applications installed in the virtual machine. The order of the returned list of applications isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of applications to return. If not specified all the applications are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def application_service(self, id): """ Returns a reference to the service that provides information about a specific application. """ Service._check_types([ ('id', id, str), ]) return VmApplicationService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.application_service(path) return self.application_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmApplicationsService:%s' % self._path
A service that provides information about applications installed in a virtual machine.
View Source
def __init__(self, connection, path): super(VmApplicationsService, self).__init__(connection, path) self._application_service = None
Creates a new service that will use the given connection and path.
#
def
list(
self,
filter=None,
follow=None,
max=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns a list of applications installed in the virtual machine. The order of the returned list of applications isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of applications to return. If not specified all the applications are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns a list of applications installed in the virtual machine. The order of the returned list of applications isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of applications to return. If not specified all the applications are returned.
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def application_service(self, id): """ Returns a reference to the service that provides information about a specific application. """ Service._check_types([ ('id', id, str), ]) return VmApplicationService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service that provides information about a specific application.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.application_service(path) return self.application_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmBackupService(Service): """ A service managing a backup of a virtual machines. """ def __init__(self, connection, path): super(VmBackupService, self).__init__(connection, path) self._disks_service = None def finalize( self, headers=None, query=None, wait=True, **kwargs ): """ Finalize the virtual machine backup entity. End backup, unlock resources, and perform cleanups. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'finalize', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns information about the virtual machine backup. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disks_service(self): """ A reference to the service that lists the disks in backup. """ return VmBackupDisksService(self._connection, '%s/disks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmBackupService:%s' % self._path
A service managing a backup of a virtual machines.
View Source
def __init__(self, connection, path): super(VmBackupService, self).__init__(connection, path) self._disks_service = None
Creates a new service that will use the given connection and path.
View Source
def finalize( self, headers=None, query=None, wait=True, **kwargs ): """ Finalize the virtual machine backup entity. End backup, unlock resources, and perform cleanups. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'finalize', None, headers, query, wait)
Finalize the virtual machine backup entity. End backup, unlock resources, and perform cleanups.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns information about the virtual machine backup. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns information about the virtual machine backup.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disks_service(self): """ A reference to the service that lists the disks in backup. """ return VmBackupDisksService(self._connection, '%s/disks' % self._path)
A reference to the service that lists the disks in backup.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmBackupDiskService(Service): """ """ def __init__(self, connection, path): super(VmBackupDiskService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmBackupDiskService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmBackupDiskService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the description of the disk.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmBackupDisksService(Service): """ """ def __init__(self, connection, path): super(VmBackupDisksService, self).__init__(connection, path) self._disk_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks in backup. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified, all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ A reference to the service that manages a specific disk. """ Service._check_types([ ('id', id, str), ]) return VmBackupDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmBackupDisksService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmBackupDisksService, self).__init__(connection, path) self._disk_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks in backup. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified, all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of disks in backup.
This method supports the following parameters:
max:: Sets the maximum number of disks to return. If not specified, all the disks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disk_service(self, id): """ A reference to the service that manages a specific disk. """ Service._check_types([ ('id', id, str), ]) return VmBackupDiskService(self._connection, '%s/%s' % (self._path, id))
A reference to the service that manages a specific disk.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmBackupsService(Service): """ Lists the backups of a virtual machine. """ def __init__(self, connection, path): super(VmBackupsService, self).__init__(connection, path) self._backup_service = None def add( self, backup, require_consistency=None, headers=None, query=None, wait=True, **kwargs ): """ Adds a new backup entity to a virtual machine. For example, to start a new incremental backup of a virtual machine since checkpoint id `previous-checkpoint-uuid`, send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/backups ---- With a request body like this: [source,xml] ---- <backup> <from_checkpoint_id>previous-checkpoint-uuid</from_checkpoint_id> <disks> <disk id="disk-uuid" /> ... </disks> </backup> ---- The response body: [source,xml] ---- <backup id="backup-uuid"> <from_checkpoint_id>previous-checkpoint-uuid</from_checkpoint_id> <to_checkpoint_id>new-checkpoint-uuid</to_checkpoint_id> <disks> <disk id="disk-uuid" /> ... ... </disks> <status>initializing</status> <creation_date> </backup> ---- This method supports the following parameters: `backup`:: The information about the virtual machine backup entity. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('backup', backup, types.Backup), ('require_consistency', require_consistency, bool), ]) # Build the URL: query = query or {} if require_consistency is not None: require_consistency = Writer.render_boolean(require_consistency) query['require_consistency'] = require_consistency # Send the request and wait for the response: return self._internal_add(backup, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ The list of virtual machine backups. This method supports the following parameters: `max`:: Sets the maximum number of virtual machine backups to return. If not specified, all the virtual machine backups are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def backup_service(self, id): """ Returns a reference to the service that manages a specific VM backup. """ Service._check_types([ ('id', id, str), ]) return VmBackupService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.backup_service(path) return self.backup_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmBackupsService:%s' % self._path
Lists the backups of a virtual machine.
View Source
def __init__(self, connection, path): super(VmBackupsService, self).__init__(connection, path) self._backup_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, backup, require_consistency=None, headers=None, query=None, wait=True, **kwargs ): """ Adds a new backup entity to a virtual machine. For example, to start a new incremental backup of a virtual machine since checkpoint id `previous-checkpoint-uuid`, send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/backups ---- With a request body like this: [source,xml] ---- <backup> <from_checkpoint_id>previous-checkpoint-uuid</from_checkpoint_id> <disks> <disk id="disk-uuid" /> ... </disks> </backup> ---- The response body: [source,xml] ---- <backup id="backup-uuid"> <from_checkpoint_id>previous-checkpoint-uuid</from_checkpoint_id> <to_checkpoint_id>new-checkpoint-uuid</to_checkpoint_id> <disks> <disk id="disk-uuid" /> ... ... </disks> <status>initializing</status> <creation_date> </backup> ---- This method supports the following parameters: `backup`:: The information about the virtual machine backup entity. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('backup', backup, types.Backup), ('require_consistency', require_consistency, bool), ]) # Build the URL: query = query or {} if require_consistency is not None: require_consistency = Writer.render_boolean(require_consistency) query['require_consistency'] = require_consistency # Send the request and wait for the response: return self._internal_add(backup, headers, query, wait)
Adds a new backup entity to a virtual machine.
For example, to start a new incremental backup of a virtual machine
since checkpoint id previous-checkpoint-uuid, send a request like this:
[source]
POST /ovirt-engine/api/vms/123/backups
With a request body like this:
[source,xml]
The response body:
[source,xml]
This method supports the following parameters:
backup:: The information about the virtual machine backup entity.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ The list of virtual machine backups. This method supports the following parameters: `max`:: Sets the maximum number of virtual machine backups to return. If not specified, all the virtual machine backups are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
The list of virtual machine backups.
This method supports the following parameters:
max:: Sets the maximum number of virtual machine backups to return. If not specified, all the virtual machine backups are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def backup_service(self, id): """ Returns a reference to the service that manages a specific VM backup. """ Service._check_types([ ('id', id, str), ]) return VmBackupService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service that manages a specific VM backup.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.backup_service(path) return self.backup_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmCdromService(Service): """ Manages a CDROM device of a virtual machine. Changing and ejecting the disk is done using always the `update` method, to change the value of the `file` attribute. """ def __init__(self, connection, path): super(VmCdromService, self).__init__(connection, path) def get( self, current=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about this CDROM device. The information consists of `cdrom` attribute containing reference to the CDROM device, the virtual machine, and optionally the inserted disk. If there is a disk inserted then the `file` attribute will contain a reference to the ISO image: [source,xml] ---- <cdrom href="..." id="00000000-0000-0000-0000-000000000000"> <file id="mycd.iso"/> <vm href="/ovirt-engine/api/vms/123" id="123"/> </cdrom> ---- If there is no disk inserted then the `file` attribute won't be reported: [source,xml] ---- <cdrom href="..." id="00000000-0000-0000-0000-000000000000"> <vm href="/ovirt-engine/api/vms/123" id="123"/> </cdrom> ---- This method supports the following parameters: `current`:: Indicates if the operation should return the information for the currently running virtual machine. This parameter is optional, and the default value is `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('current', current, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if current is not None: current = Writer.render_boolean(current) query['current'] = current if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def update( self, cdrom, current=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the information about this CDROM device. It allows to change or eject the disk by changing the value of the `file` attribute. For example, to insert or change the disk send a request like this: [source] ---- PUT /ovirt-engine/api/vms/123/cdroms/00000000-0000-0000-0000-000000000000 ---- The body should contain the new value for the `file` attribute: [source,xml] ---- <cdrom> <file id="mycd.iso"/> </cdrom> ---- The value of the `id` attribute, `mycd.iso` in this example, should correspond to a file available in an attached ISO storage domain. To eject the disk use a `file` with an empty `id`: [source,xml] ---- <cdrom> <file id=""/> </cdrom> ---- By default the above operations change permanently the disk that will be visible to the virtual machine after the next boot, but they don't have any effect on the currently running virtual machine. If you want to change the disk that is visible to the current running virtual machine, add the `current=true` parameter. For example, to eject the current disk send a request like this: [source] ---- PUT /ovirt-engine/api/vms/123/cdroms/00000000-0000-0000-0000-000000000000?current=true ---- With a request body like this: [source,xml] ---- <cdrom> <file id=""/> </cdrom> ---- IMPORTANT: The changes made with the `current=true` parameter are never persisted, so they won't have any effect after the virtual machine is rebooted. This method supports the following parameters: `cdrom`:: The information about the CDROM device. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('cdrom', cdrom, types.Cdrom), ('current', current, bool), ]) # Build the URL: query = query or {} if current is not None: current = Writer.render_boolean(current) query['current'] = current # Send the request and wait for the response: return self._internal_update(cdrom, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmCdromService:%s' % self._path
Manages a CDROM device of a virtual machine.
Changing and ejecting the disk is done using always the update method, to change the value of the file
attribute.
View Source
def __init__(self, connection, path): super(VmCdromService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, current=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about this CDROM device. The information consists of `cdrom` attribute containing reference to the CDROM device, the virtual machine, and optionally the inserted disk. If there is a disk inserted then the `file` attribute will contain a reference to the ISO image: [source,xml] ---- <cdrom href="..." id="00000000-0000-0000-0000-000000000000"> <file id="mycd.iso"/> <vm href="/ovirt-engine/api/vms/123" id="123"/> </cdrom> ---- If there is no disk inserted then the `file` attribute won't be reported: [source,xml] ---- <cdrom href="..." id="00000000-0000-0000-0000-000000000000"> <vm href="/ovirt-engine/api/vms/123" id="123"/> </cdrom> ---- This method supports the following parameters: `current`:: Indicates if the operation should return the information for the currently running virtual machine. This parameter is optional, and the default value is `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('current', current, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if current is not None: current = Writer.render_boolean(current) query['current'] = current if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the information about this CDROM device.
The information consists of cdrom attribute containing reference to the CDROM device, the virtual machine,
and optionally the inserted disk.
If there is a disk inserted then the file attribute will contain a reference to the ISO image:
[source,xml]
If there is no disk inserted then the file attribute won't be reported:
[source,xml]
This method supports the following parameters:
current:: Indicates if the operation should return the information for the currently running virtual machine. This
parameter is optional, and the default value is false.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, cdrom, current=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the information about this CDROM device. It allows to change or eject the disk by changing the value of the `file` attribute. For example, to insert or change the disk send a request like this: [source] ---- PUT /ovirt-engine/api/vms/123/cdroms/00000000-0000-0000-0000-000000000000 ---- The body should contain the new value for the `file` attribute: [source,xml] ---- <cdrom> <file id="mycd.iso"/> </cdrom> ---- The value of the `id` attribute, `mycd.iso` in this example, should correspond to a file available in an attached ISO storage domain. To eject the disk use a `file` with an empty `id`: [source,xml] ---- <cdrom> <file id=""/> </cdrom> ---- By default the above operations change permanently the disk that will be visible to the virtual machine after the next boot, but they don't have any effect on the currently running virtual machine. If you want to change the disk that is visible to the current running virtual machine, add the `current=true` parameter. For example, to eject the current disk send a request like this: [source] ---- PUT /ovirt-engine/api/vms/123/cdroms/00000000-0000-0000-0000-000000000000?current=true ---- With a request body like this: [source,xml] ---- <cdrom> <file id=""/> </cdrom> ---- IMPORTANT: The changes made with the `current=true` parameter are never persisted, so they won't have any effect after the virtual machine is rebooted. This method supports the following parameters: `cdrom`:: The information about the CDROM device. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('cdrom', cdrom, types.Cdrom), ('current', current, bool), ]) # Build the URL: query = query or {} if current is not None: current = Writer.render_boolean(current) query['current'] = current # Send the request and wait for the response: return self._internal_update(cdrom, headers, query, wait)
Updates the information about this CDROM device.
It allows to change or eject the disk by changing the value of the file attribute.
For example, to insert or change the disk send a request like this:
[source]
PUT /ovirt-engine/api/vms/123/cdroms/00000000-0000-0000-0000-000000000000
The body should contain the new value for the file attribute:
[source,xml]
The value of the id attribute, mycd.iso in this example, should correspond to a file available in an
attached ISO storage domain.
To eject the disk use a file with an empty id:
[source,xml]
By default the above operations change permanently the disk that will be visible to the virtual machine
after the next boot, but they don't have any effect on the currently running virtual machine. If you want
to change the disk that is visible to the current running virtual machine, add the current=true parameter.
For example, to eject the current disk send a request like this:
[source]
PUT /ovirt-engine/api/vms/123/cdroms/00000000-0000-0000-0000-000000000000?current=true
With a request body like this:
[source,xml]
IMPORTANT: The changes made with the current=true parameter are never persisted, so they won't have any
effect after the virtual machine is rebooted.
This method supports the following parameters:
cdrom:: The information about the CDROM device.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmCdromsService(Service): """ Manages the CDROM devices of a virtual machine. Currently virtual machines have exactly one CDROM device. No new devices can be added, and the existing one can't be removed, thus there are no `add` or `remove` methods. Changing and ejecting CDROM disks is done with the <<services/vm_cdrom/methods/update, update>> method of the <<services/vm_cdrom, service>> that manages the CDROM device. """ def __init__(self, connection, path): super(VmCdromsService, self).__init__(connection, path) self._cdrom_service = None def add( self, cdrom, headers=None, query=None, wait=True, **kwargs ): """ Add a cdrom to a virtual machine identified by the given id. """ # Check the types of the parameters: Service._check_types([ ('cdrom', cdrom, types.Cdrom), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(cdrom, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of CDROM devices of the virtual machine. The order of the returned list of CD-ROM devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of CDROMs to return. If not specified all the CDROMs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def cdrom_service(self, id): """ Returns a reference to the service that manages a specific CDROM device. """ Service._check_types([ ('id', id, str), ]) return VmCdromService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.cdrom_service(path) return self.cdrom_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmCdromsService:%s' % self._path
Manages the CDROM devices of a virtual machine.
Currently virtual machines have exactly one CDROM device. No new devices can be added, and the existing one can't
be removed, thus there are no add or remove methods. Changing and ejecting CDROM disks is done with the
<
View Source
def __init__(self, connection, path): super(VmCdromsService, self).__init__(connection, path) self._cdrom_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, cdrom, headers=None, query=None, wait=True, **kwargs ): """ Add a cdrom to a virtual machine identified by the given id. """ # Check the types of the parameters: Service._check_types([ ('cdrom', cdrom, types.Cdrom), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(cdrom, headers, query, wait)
Add a cdrom to a virtual machine identified by the given id.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of CDROM devices of the virtual machine. The order of the returned list of CD-ROM devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of CDROMs to return. If not specified all the CDROMs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of CDROM devices of the virtual machine. The order of the returned list of CD-ROM devices isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of CDROMs to return. If not specified all the CDROMs are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def cdrom_service(self, id): """ Returns a reference to the service that manages a specific CDROM device. """ Service._check_types([ ('id', id, str), ]) return VmCdromService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service that manages a specific CDROM device.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.cdrom_service(path) return self.cdrom_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmCheckpointService(Service): """ A service managing a checkpoint of a virtual machines. """ def __init__(self, connection, path): super(VmCheckpointService, self).__init__(connection, path) self._disks_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns information about the virtual machine checkpoint. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the virtual machine checkpoint entity. Remove the checkpoint from libvirt and the database. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def disks_service(self): """ A reference to the service that lists the disks in checkpoint. """ return VmCheckpointDisksService(self._connection, '%s/disks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmCheckpointService:%s' % self._path
A service managing a checkpoint of a virtual machines.
View Source
def __init__(self, connection, path): super(VmCheckpointService, self).__init__(connection, path) self._disks_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns information about the virtual machine checkpoint. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns information about the virtual machine checkpoint.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the virtual machine checkpoint entity. Remove the checkpoint from libvirt and the database. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove the virtual machine checkpoint entity. Remove the checkpoint from libvirt and the database.
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disks_service(self): """ A reference to the service that lists the disks in checkpoint. """ return VmCheckpointDisksService(self._connection, '%s/disks' % self._path)
A reference to the service that lists the disks in checkpoint.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disks': return self.disks_service() if path.startswith('disks/'): return self.disks_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmCheckpointDiskService(Service): """ """ def __init__(self, connection, path): super(VmCheckpointDiskService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmCheckpointDiskService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmCheckpointDiskService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the description of the disk.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmCheckpointDisksService(Service): """ """ def __init__(self, connection, path): super(VmCheckpointDisksService, self).__init__(connection, path) self._disk_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks in checkpoint. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified, all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ A reference to the service that manages a specific disk. """ Service._check_types([ ('id', id, str), ]) return VmCheckpointDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmCheckpointDisksService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmCheckpointDisksService, self).__init__(connection, path) self._disk_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks in checkpoint. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified, all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of disks in checkpoint.
This method supports the following parameters:
max:: Sets the maximum number of disks to return. If not specified, all the disks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disk_service(self, id): """ A reference to the service that manages a specific disk. """ Service._check_types([ ('id', id, str), ]) return VmCheckpointDiskService(self._connection, '%s/%s' % (self._path, id))
A reference to the service that manages a specific disk.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmCheckpointsService(Service): """ Lists the checkpoints of a virtual machine. """ def __init__(self, connection, path): super(VmCheckpointsService, self).__init__(connection, path) self._checkpoint_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ The list of virtual machine checkpoints. This method supports the following parameters: `max`:: Sets the maximum number of virtual machine checkpoints to return. If not specified, all the virtual machine checkpoints are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def checkpoint_service(self, id): """ Returns a reference to the service that manages a specific VM checkpoint. """ Service._check_types([ ('id', id, str), ]) return VmCheckpointService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.checkpoint_service(path) return self.checkpoint_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmCheckpointsService:%s' % self._path
Lists the checkpoints of a virtual machine.
View Source
def __init__(self, connection, path): super(VmCheckpointsService, self).__init__(connection, path) self._checkpoint_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ The list of virtual machine checkpoints. This method supports the following parameters: `max`:: Sets the maximum number of virtual machine checkpoints to return. If not specified, all the virtual machine checkpoints are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
The list of virtual machine checkpoints.
This method supports the following parameters:
max:: Sets the maximum number of virtual machine checkpoints to return.
If not specified, all the virtual machine checkpoints are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def checkpoint_service(self, id): """ Returns a reference to the service that manages a specific VM checkpoint. """ Service._check_types([ ('id', id, str), ]) return VmCheckpointService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service that manages a specific VM checkpoint.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.checkpoint_service(path) return self.checkpoint_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmDiskService(MeasurableService): """ """ def __init__(self, connection, path): super(VmDiskService, self).__init__(connection, path) self._permissions_service = None self._statistics_service = None def activate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait) def deactivate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the deactivation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'deactivate', None, headers, query, wait) def export( self, async_=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the export should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def move( self, async_=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the move should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait) def reduce( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Reduces the size of the disk image. Invokes _reduce_ on the logical volume (i.e. this is only applicable for block storage domains). This is applicable for floating disks and disks attached to non-running virtual machines. There is no need to specify the size as the optimal size is calculated automatically. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reduce', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Detach the disk from the virtual machine. NOTE: In version 3 of the API this used to also remove the disk completely from the system, but starting with version 4 it doesn't. If you need to remove it completely use the <<services/disk/methods/remove,remove method of the top level disk service>>. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, disk, async_=None, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(disk, headers, query, wait) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmDiskService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmDiskService, self).__init__(connection, path) self._permissions_service = None self._statistics_service = None
Creates a new service that will use the given connection and path.
View Source
def activate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the activation should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def deactivate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the deactivation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'deactivate', None, headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the deactivation should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def export( self, async_=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the export should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the export should be performed asynchronously.
filter:: Indicates if the results should be filtered according to the permissions of the user.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def move( self, async_=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the move should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the move should be performed asynchronously.
filter:: Indicates if the results should be filtered according to the permissions of the user.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def reduce( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Reduces the size of the disk image. Invokes _reduce_ on the logical volume (i.e. this is only applicable for block storage domains). This is applicable for floating disks and disks attached to non-running virtual machines. There is no need to specify the size as the optimal size is calculated automatically. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reduce', None, headers, query, wait)
Reduces the size of the disk image. Invokes _reduce_ on the logical volume (i.e. this is only applicable for block storage domains). This is applicable for floating disks and disks attached to non-running virtual machines. There is no need to specify the size as the optimal size is calculated automatically.
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Detach the disk from the virtual machine. NOTE: In version 3 of the API this used to also remove the disk completely from the system, but starting with version 4 it doesn't. If you need to remove it completely use the <<services/disk/methods/remove,remove method of the top level disk service>>. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Detach the disk from the virtual machine.
NOTE: In version 3 of the API this used to also remove the disk completely from the system, but starting with
version 4 it doesn't. If you need to remove it completely use the <
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, disk, async_=None, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(disk, headers, query, wait)
View Source
def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
View Source
def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmDisksService(Service): """ """ def __init__(self, connection, path): super(VmDisksService, self).__init__(connection, path) self._disk_service = None def add( self, disk, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks of the virtual machine. The order of the returned list of disks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def disk_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmDiskService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmDisksService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmDisksService, self).__init__(connection, path) self._disk_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, disk, headers=None, query=None, wait=True, **kwargs ): """ """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(disk, headers, query, wait)
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of disks of the virtual machine. The order of the returned list of disks isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of disks to return. If not specified all the disks are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of disks of the virtual machine. The order of the returned list of disks isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of disks to return. If not specified all the disks are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disk_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmDiskService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.disk_service(path) return self.disk_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmGraphicsConsoleService(Service): """ """ def __init__(self, connection, path): super(VmGraphicsConsoleService, self).__init__(connection, path) def get( self, current=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the graphics console configuration of the virtual machine. IMPORTANT: By default, when the `current` parameter is not specified, the data returned corresponds to the next execution of the virtual machine. In the current implementation of the system this means that the `address` and `port` attributes will not be populated because the system does not know what address and port will be used for the next execution. Since in most cases those attributes are needed, it is strongly advised to aways explicitly include the `current` parameter with the value `true`. This method supports the following parameters: `current`:: Specifies if the data returned should correspond to the next execution of the virtual machine, or to the current execution. IMPORTANT: The `address` and `port` attributes will not be populated unless the value is `true`. For example, to get data for the current execution of the virtual machine, including the `address` and `port` attributes, send a request like this: [source] ---- GET /ovit-engine/api/vms/123/graphicsconsoles/456?current=true ---- The default value is `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('current', current, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if current is not None: current = Writer.render_boolean(current) query['current'] = current if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def proxy_ticket( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the generation of the ticket should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'proxyticket', 'proxy_ticket', headers, query, wait) def remote_viewer_connection_file( self, headers=None, query=None, wait=True, **kwargs ): """ Generates the file which is compatible with `remote-viewer` client. Use the following request to generate remote viewer connection file of the graphics console. Note that this action generates the file only if virtual machine is running. [source] ---- POST /ovirt-engine/api/vms/123/graphicsconsoles/456/remoteviewerconnectionfile ---- The `remoteviewerconnectionfile` action does not take any action specific parameters, so the request body should contain an empty `action`: [source,xml] ---- <action/> ---- The response contains the file, which can be used with `remote-viewer` client. [source,xml] ---- <action> <remote_viewer_connection_file> [virt-viewer] type=spice host=192.168.1.101 port=-1 password=123456789 delete-this-file=1 fullscreen=0 toggle-fullscreen=shift+f11 release-cursor=shift+f12 secure-attention=ctrl+alt+end tls-port=5900 enable-smartcard=0 enable-usb-autoshare=0 usb-filter=null tls-ciphers=DEFAULT host-subject=O=local,CN=example.com ca=... </remote_viewer_connection_file> </action> ---- E.g., to fetch the content of remote viewer connection file and save it into temporary file, user can use oVirt Python SDK as follows: [source,python] ---- # Find the virtual machine: vm = vms_service.list(search='name=myvm')[0] # Locate the service that manages the virtual machine, as that is where # the locators are defined: vm_service = vms_service.vm_service(vm.id) # Find the graphic console of the virtual machine: graphics_consoles_service = vm_service.graphics_consoles_service() graphics_console = graphics_consoles_service.list()[0] # Generate the remote viewer connection file: console_service = graphics_consoles_service.console_service(graphics_console.id) remote_viewer_connection_file = console_service.remote_viewer_connection_file() # Write the content to file "/tmp/remote_viewer_connection_file.vv" path = "/tmp/remote_viewer_connection_file.vv" with open(path, "w") as f: f.write(remote_viewer_connection_file) ---- When you create the remote viewer connection file, then you can connect to virtual machine graphic console, as follows: [source,bash] ---- #!/bin/sh -ex remote-viewer --ovirt-ca-file=/etc/pki/ovirt-engine/ca.pem /tmp/remote_viewer_connection_file.vv ---- """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'remoteviewerconnectionfile', 'remote_viewer_connection_file', headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the graphics console from the virtual machine. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def ticket( self, ticket=None, headers=None, query=None, wait=True, **kwargs ): """ Generates a time-sensitive authentication token for accessing this virtual machine's console. [source] ---- POST /ovirt-engine/api/vms/123/graphicsconsoles/456/ticket ---- The client-provided action optionally includes a desired ticket value and/or an expiry time in seconds. In any case, the response specifies the actual ticket value and expiry used. [source,xml] ---- <action> <ticket> <value>abcd12345</value> <expiry>120</expiry> </ticket> </action> ---- This method supports the following parameters: `ticket`:: The generated ticket that can be used to access this console. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('ticket', ticket, types.Ticket), ]) # Populate the action: action = types.Action( ticket=ticket, ) # Send the request and wait for the response: return self._internal_action(action, 'ticket', 'ticket', headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmGraphicsConsoleService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmGraphicsConsoleService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, current=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the graphics console configuration of the virtual machine. IMPORTANT: By default, when the `current` parameter is not specified, the data returned corresponds to the next execution of the virtual machine. In the current implementation of the system this means that the `address` and `port` attributes will not be populated because the system does not know what address and port will be used for the next execution. Since in most cases those attributes are needed, it is strongly advised to aways explicitly include the `current` parameter with the value `true`. This method supports the following parameters: `current`:: Specifies if the data returned should correspond to the next execution of the virtual machine, or to the current execution. IMPORTANT: The `address` and `port` attributes will not be populated unless the value is `true`. For example, to get data for the current execution of the virtual machine, including the `address` and `port` attributes, send a request like this: [source] ---- GET /ovit-engine/api/vms/123/graphicsconsoles/456?current=true ---- The default value is `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('current', current, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if current is not None: current = Writer.render_boolean(current) query['current'] = current if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the graphics console configuration of the virtual machine.
IMPORTANT: By default, when the current parameter is not specified, the data returned
corresponds to the next execution of the virtual machine. In the current implementation of
the system this means that the address and port attributes will not be populated because
the system does not know what address and port will be used for the next execution. Since in most
cases those attributes are needed, it is strongly advised to aways explicitly include the
current parameter with the value true.
This method supports the following parameters:
current:: Specifies if the data returned should correspond to the next execution of
the virtual machine, or to the current execution.
IMPORTANT: The address and port attributes will not be populated unless the value is
true.
For example, to get data for the current execution of the virtual machine, including the
address and port attributes, send a request like this:
[source]
GET /ovit-engine/api/vms/123/graphicsconsoles/456?current=true
The default value is false.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def proxy_ticket( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the generation of the ticket should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'proxyticket', 'proxy_ticket', headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the generation of the ticket should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remote_viewer_connection_file( self, headers=None, query=None, wait=True, **kwargs ): """ Generates the file which is compatible with `remote-viewer` client. Use the following request to generate remote viewer connection file of the graphics console. Note that this action generates the file only if virtual machine is running. [source] ---- POST /ovirt-engine/api/vms/123/graphicsconsoles/456/remoteviewerconnectionfile ---- The `remoteviewerconnectionfile` action does not take any action specific parameters, so the request body should contain an empty `action`: [source,xml] ---- <action/> ---- The response contains the file, which can be used with `remote-viewer` client. [source,xml] ---- <action> <remote_viewer_connection_file> [virt-viewer] type=spice host=192.168.1.101 port=-1 password=123456789 delete-this-file=1 fullscreen=0 toggle-fullscreen=shift+f11 release-cursor=shift+f12 secure-attention=ctrl+alt+end tls-port=5900 enable-smartcard=0 enable-usb-autoshare=0 usb-filter=null tls-ciphers=DEFAULT host-subject=O=local,CN=example.com ca=... </remote_viewer_connection_file> </action> ---- E.g., to fetch the content of remote viewer connection file and save it into temporary file, user can use oVirt Python SDK as follows: [source,python] ---- # Find the virtual machine: vm = vms_service.list(search='name=myvm')[0] # Locate the service that manages the virtual machine, as that is where # the locators are defined: vm_service = vms_service.vm_service(vm.id) # Find the graphic console of the virtual machine: graphics_consoles_service = vm_service.graphics_consoles_service() graphics_console = graphics_consoles_service.list()[0] # Generate the remote viewer connection file: console_service = graphics_consoles_service.console_service(graphics_console.id) remote_viewer_connection_file = console_service.remote_viewer_connection_file() # Write the content to file "/tmp/remote_viewer_connection_file.vv" path = "/tmp/remote_viewer_connection_file.vv" with open(path, "w") as f: f.write(remote_viewer_connection_file) ---- When you create the remote viewer connection file, then you can connect to virtual machine graphic console, as follows: [source,bash] ---- #!/bin/sh -ex remote-viewer --ovirt-ca-file=/etc/pki/ovirt-engine/ca.pem /tmp/remote_viewer_connection_file.vv ---- """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'remoteviewerconnectionfile', 'remote_viewer_connection_file', headers, query, wait)
Generates the file which is compatible with remote-viewer client.
Use the following request to generate remote viewer connection file of the graphics console.
Note that this action generates the file only if virtual machine is running.
[source]
POST /ovirt-engine/api/vms/123/graphicsconsoles/456/remoteviewerconnectionfile
The remoteviewerconnectionfile action does not take any action specific parameters,
so the request body should contain an empty action:
[source,xml]
The response contains the file, which can be used with remote-viewer client.
[source,xml]
E.g., to fetch the content of remote viewer connection file and save it into temporary file, user can use oVirt Python SDK as follows:
[source,python]
Find the virtual machine:
vm = vms_service.list(search='name=myvm')[0]
Locate the service that manages the virtual machine, as that is where
the locators are defined:
vm_service = vms_service.vm_service(vm.id)
Find the graphic console of the virtual machine:
graphics_consoles_service = vm_service.graphics_consoles_service() graphics_console = graphics_consoles_service.list()[0]
Generate the remote viewer connection file:
console_service = graphics_consoles_service.console_service(graphics_console.id) remote_viewer_connection_file = console_service.remote_viewer_connection_file()
Write the content to file "/tmp/remote_viewer_connection_file.vv"
path = "/tmp/remote_viewer_connection_file.vv" with open(path, "w") as f:
f.write(remote_viewer_connection_file)
When you create the remote viewer connection file, then you can connect to virtual machine graphic console, as follows:
[source,bash]
!/bin/sh -ex
remote-viewer --ovirt-ca-file=/etc/pki/ovirt-engine/ca.pem /tmp/remote_viewer_connection_file.vv
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the graphics console from the virtual machine. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove the graphics console from the virtual machine.
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def ticket( self, ticket=None, headers=None, query=None, wait=True, **kwargs ): """ Generates a time-sensitive authentication token for accessing this virtual machine's console. [source] ---- POST /ovirt-engine/api/vms/123/graphicsconsoles/456/ticket ---- The client-provided action optionally includes a desired ticket value and/or an expiry time in seconds. In any case, the response specifies the actual ticket value and expiry used. [source,xml] ---- <action> <ticket> <value>abcd12345</value> <expiry>120</expiry> </ticket> </action> ---- This method supports the following parameters: `ticket`:: The generated ticket that can be used to access this console. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('ticket', ticket, types.Ticket), ]) # Populate the action: action = types.Action( ticket=ticket, ) # Send the request and wait for the response: return self._internal_action(action, 'ticket', 'ticket', headers, query, wait)
Generates a time-sensitive authentication token for accessing this virtual machine's console.
[source]
POST /ovirt-engine/api/vms/123/graphicsconsoles/456/ticket
The client-provided action optionally includes a desired ticket value and/or an expiry time in seconds. In any case, the response specifies the actual ticket value and expiry used.
[source,xml]
This method supports the following parameters:
ticket:: The generated ticket that can be used to access this console.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmGraphicsConsolesService(Service): """ """ def __init__(self, connection, path): super(VmGraphicsConsolesService, self).__init__(connection, path) self._console_service = None def add( self, console, headers=None, query=None, wait=True, **kwargs ): """ Add new graphics console to the virtual machine. """ # Check the types of the parameters: Service._check_types([ ('console', console, types.GraphicsConsole), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(console, headers, query, wait) def list( self, current=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured graphics consoles of the virtual machine. IMPORTANT: By default, when the `current` parameter is not specified, the data returned corresponds to the next execution of the virtual machine. In the current implementation of the system this means that the `address` and `port` attributes will not be populated because the system does not know what address and port will be used for the next execution. Since in most cases those attributes are needed, it is strongly advised to aways explicitly include the `current` parameter with the value `true`. The order of the returned list of graphics consoles is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of consoles to return. If not specified all the consoles are returned. `current`:: Specifies if the data returned should correspond to the next execution of the virtual machine, or to the current execution. IMPORTANT: The `address` and `port` attributes will not be populated unless the value is `true`. For example, to get data for the current execution of the virtual machine, including the `address` and `port` attributes, send a request like this: [source] ---- GET /ovirt-engine/api/vms/123/graphicsconsoles?current=true ---- The default value is `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('current', current, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if current is not None: current = Writer.render_boolean(current) query['current'] = current if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def console_service(self, id): """ Returns a reference to the service that manages a specific virtual machine graphics console. """ Service._check_types([ ('id', id, str), ]) return VmGraphicsConsoleService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.console_service(path) return self.console_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmGraphicsConsolesService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmGraphicsConsolesService, self).__init__(connection, path) self._console_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, console, headers=None, query=None, wait=True, **kwargs ): """ Add new graphics console to the virtual machine. """ # Check the types of the parameters: Service._check_types([ ('console', console, types.GraphicsConsole), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(console, headers, query, wait)
Add new graphics console to the virtual machine.
#
def
list(
self,
current=None,
follow=None,
max=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, current=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all the configured graphics consoles of the virtual machine. IMPORTANT: By default, when the `current` parameter is not specified, the data returned corresponds to the next execution of the virtual machine. In the current implementation of the system this means that the `address` and `port` attributes will not be populated because the system does not know what address and port will be used for the next execution. Since in most cases those attributes are needed, it is strongly advised to aways explicitly include the `current` parameter with the value `true`. The order of the returned list of graphics consoles is not guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of consoles to return. If not specified all the consoles are returned. `current`:: Specifies if the data returned should correspond to the next execution of the virtual machine, or to the current execution. IMPORTANT: The `address` and `port` attributes will not be populated unless the value is `true`. For example, to get data for the current execution of the virtual machine, including the `address` and `port` attributes, send a request like this: [source] ---- GET /ovirt-engine/api/vms/123/graphicsconsoles?current=true ---- The default value is `false`. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('current', current, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if current is not None: current = Writer.render_boolean(current) query['current'] = current if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists all the configured graphics consoles of the virtual machine.
IMPORTANT: By default, when the current parameter is not specified, the data returned
corresponds to the next execution of the virtual machine. In the current implementation of
the system this means that the address and port attributes will not be populated because
the system does not know what address and port will be used for the next execution. Since in most
cases those attributes are needed, it is strongly advised to aways explicitly include the
current parameter with the value true.
The order of the returned list of graphics consoles is not guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of consoles to return. If not specified all the consoles are returned.
current:: Specifies if the data returned should correspond to the next execution of
the virtual machine, or to the current execution.
IMPORTANT: The address and port attributes will not be populated unless the value is
true.
For example, to get data for the current execution of the virtual machine, including the
address and port attributes, send a request like this:
[source]
GET /ovirt-engine/api/vms/123/graphicsconsoles?current=true
The default value is false.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def console_service(self, id): """ Returns a reference to the service that manages a specific virtual machine graphics console. """ Service._check_types([ ('id', id, str), ]) return VmGraphicsConsoleService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service that manages a specific virtual machine graphics console.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.console_service(path) return self.console_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmHostDeviceService(Service): """ A service to manage individual host device attached to a virtual machine. """ def __init__(self, connection, path): super(VmHostDeviceService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieve information about particular host device attached to given virtual machine. Example: [source] ---- GET /ovirt-engine/api/vms/123/hostdevices/456 ---- [source,xml] ---- <host_device href="/ovirt-engine/api/hosts/543/devices/456" id="456"> <name>pci_0000_04_00_0</name> <capability>pci</capability> <iommu_group>30</iommu_group> <placeholder>true</placeholder> <product id="0x13ba"> <name>GM107GL [Quadro K2200]</name> </product> <vendor id="0x10de"> <name>NVIDIA Corporation</name> </vendor> <host href="/ovirt-engine/api/hosts/543" id="543"/> <parent_device href="/ovirt-engine/api/hosts/543/devices/456" id="456"> <name>pci_0000_00_03_0</name> </parent_device> <vm href="/ovirt-engine/api/vms/123" id="123"/> </host_device> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the attachment of this host device from given virtual machine. NOTE: In case this device serves as an IOMMU placeholder, it cannot be removed (remove will result only in setting its `placeholder` flag to `true`). Note that all IOMMU placeholder devices will be removed automatically as soon as there will be no more non-placeholder devices (all devices from given IOMMU group are detached). [source] ---- DELETE /ovirt-engine/api/vms/123/hostdevices/456 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmHostDeviceService:%s' % self._path
A service to manage individual host device attached to a virtual machine.
View Source
def __init__(self, connection, path): super(VmHostDeviceService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieve information about particular host device attached to given virtual machine. Example: [source] ---- GET /ovirt-engine/api/vms/123/hostdevices/456 ---- [source,xml] ---- <host_device href="/ovirt-engine/api/hosts/543/devices/456" id="456"> <name>pci_0000_04_00_0</name> <capability>pci</capability> <iommu_group>30</iommu_group> <placeholder>true</placeholder> <product id="0x13ba"> <name>GM107GL [Quadro K2200]</name> </product> <vendor id="0x10de"> <name>NVIDIA Corporation</name> </vendor> <host href="/ovirt-engine/api/hosts/543" id="543"/> <parent_device href="/ovirt-engine/api/hosts/543/devices/456" id="456"> <name>pci_0000_00_03_0</name> </parent_device> <vm href="/ovirt-engine/api/vms/123" id="123"/> </host_device> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieve information about particular host device attached to given virtual machine. Example:
[source]
GET /ovirt-engine/api/vms/123/hostdevices/456
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the attachment of this host device from given virtual machine. NOTE: In case this device serves as an IOMMU placeholder, it cannot be removed (remove will result only in setting its `placeholder` flag to `true`). Note that all IOMMU placeholder devices will be removed automatically as soon as there will be no more non-placeholder devices (all devices from given IOMMU group are detached). [source] ---- DELETE /ovirt-engine/api/vms/123/hostdevices/456 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove the attachment of this host device from given virtual machine.
NOTE: In case this device serves as an IOMMU placeholder, it cannot be removed (remove will result only
in setting its placeholder flag to true). Note that all IOMMU placeholder devices will be removed
automatically as soon as there will be no more non-placeholder devices (all devices from given IOMMU
group are detached).
[source]
DELETE /ovirt-engine/api/vms/123/hostdevices/456
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmHostDevicesService(Service): """ A service to manage host devices attached to a virtual machine. """ def __init__(self, connection, path): super(VmHostDevicesService, self).__init__(connection, path) self._device_service = None def add( self, device, headers=None, query=None, wait=True, **kwargs ): """ Attach target device to given virtual machine. Example: [source] ---- POST /ovirt-engine/api/vms/123/hostdevices ---- With request body of type <<types/host_device,HostDevice>>, for example [source,xml] ---- <host_device id="123" /> ---- NOTE: A necessary precondition for a successful host device attachment is that the virtual machine must be pinned to *exactly* one host. The device ID is then taken relative to this host. NOTE: Attachment of a PCI device that is part of a bigger IOMMU group will result in attachment of the remaining devices from that IOMMU group as "placeholders". These devices are then identified using the `placeholder` attribute of the <<types/host_device,HostDevice>> type set to `true`. In case you want attach a device that already serves as an IOMMU placeholder, simply issue an explicit Add operation for it, and its `placeholder` flag will be cleared, and the device will be accessible to the virtual machine. This method supports the following parameters: `device`:: The host device to be attached to given virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('device', device, types.HostDevice), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(device, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the host devices assigned to given virtual machine. The order of the returned list of devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of devices to return. If not specified all the devices are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def device_service(self, id): """ Returns a reference to the service that manages a specific host device attached to given virtual machine. """ Service._check_types([ ('id', id, str), ]) return VmHostDeviceService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.device_service(path) return self.device_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmHostDevicesService:%s' % self._path
A service to manage host devices attached to a virtual machine.
View Source
def __init__(self, connection, path): super(VmHostDevicesService, self).__init__(connection, path) self._device_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, device, headers=None, query=None, wait=True, **kwargs ): """ Attach target device to given virtual machine. Example: [source] ---- POST /ovirt-engine/api/vms/123/hostdevices ---- With request body of type <<types/host_device,HostDevice>>, for example [source,xml] ---- <host_device id="123" /> ---- NOTE: A necessary precondition for a successful host device attachment is that the virtual machine must be pinned to *exactly* one host. The device ID is then taken relative to this host. NOTE: Attachment of a PCI device that is part of a bigger IOMMU group will result in attachment of the remaining devices from that IOMMU group as "placeholders". These devices are then identified using the `placeholder` attribute of the <<types/host_device,HostDevice>> type set to `true`. In case you want attach a device that already serves as an IOMMU placeholder, simply issue an explicit Add operation for it, and its `placeholder` flag will be cleared, and the device will be accessible to the virtual machine. This method supports the following parameters: `device`:: The host device to be attached to given virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('device', device, types.HostDevice), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(device, headers, query, wait)
Attach target device to given virtual machine. Example:
[source]
POST /ovirt-engine/api/vms/123/hostdevices
With request body of type <
[source,xml]
NOTE: A necessary precondition for a successful host device attachment is that the virtual machine must be pinned
to exactly one host. The device ID is then taken relative to this host.
NOTE: Attachment of a PCI device that is part of a bigger IOMMU group will result in attachment of the remaining
devices from that IOMMU group as "placeholders". These devices are then identified using the placeholder
attribute of the <true.
In case you want attach a device that already serves as an IOMMU placeholder, simply issue an explicit Add operation
for it, and its placeholder flag will be cleared, and the device will be accessible to the virtual machine.
This method supports the following parameters:
device:: The host device to be attached to given virtual machine.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List the host devices assigned to given virtual machine. The order of the returned list of devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of devices to return. If not specified all the devices are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List the host devices assigned to given virtual machine. The order of the returned list of devices isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of devices to return. If not specified all the devices are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def device_service(self, id): """ Returns a reference to the service that manages a specific host device attached to given virtual machine. """ Service._check_types([ ('id', id, str), ]) return VmHostDeviceService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service that manages a specific host device attached to given virtual machine.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.device_service(path) return self.device_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmNicService(MeasurableService): """ """ def __init__(self, connection, path): super(VmNicService, self).__init__(connection, path) self._network_filter_parameters_service = None self._reported_devices_service = None self._statistics_service = None def activate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait) def deactivate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the deactivation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'deactivate', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the NIC. For example, to remove the NIC with id `456` from the virtual machine with id `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/vms/123/nics/456 ---- [IMPORTANT] ==== The hotplugging feature only supports virtual machine operating systems with hotplugging operations. Example operating systems include: - Red Hat Enterprise Linux 6 - Red Hat Enterprise Linux 5 - Windows Server 2008 and - Windows Server 2003 ==== This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, nic, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the NIC. For example, to update the NIC having with `456` belonging to virtual the machine with id `123` send a request like this: [source] ---- PUT /ovirt-engine/api/vms/123/nics/456 ---- With a request body like this: [source,xml] ---- <nic> <name>mynic</name> <interface>e1000</interface> <vnic_profile id='789'/> </nic> ---- [IMPORTANT] ==== The hotplugging feature only supports virtual machine operating systems with hotplugging operations. Example operating systems include: - Red Hat Enterprise Linux 6 - Red Hat Enterprise Linux 5 - Windows Server 2008 and - Windows Server 2003 ==== """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(nic, headers, query, wait) def network_filter_parameters_service(self): """ Reference to the service that manages the network filter parameters of the NIC. A single top-level network filter may assigned to the NIC by the NIC's <<types/vnic_profile,vNIC Profile>>. """ return NicNetworkFilterParametersService(self._connection, '%s/networkfilterparameters' % self._path) def reported_devices_service(self): """ """ return VmReportedDevicesService(self._connection, '%s/reporteddevices' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'networkfilterparameters': return self.network_filter_parameters_service() if path.startswith('networkfilterparameters/'): return self.network_filter_parameters_service().service(path[24:]) if path == 'reporteddevices': return self.reported_devices_service() if path.startswith('reporteddevices/'): return self.reported_devices_service().service(path[16:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmNicService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmNicService, self).__init__(connection, path) self._network_filter_parameters_service = None self._reported_devices_service = None self._statistics_service = None
Creates a new service that will use the given connection and path.
View Source
def activate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the activation should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def deactivate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the deactivation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'deactivate', None, headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the deactivation should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the NIC. For example, to remove the NIC with id `456` from the virtual machine with id `123` send a request like this: [source] ---- DELETE /ovirt-engine/api/vms/123/nics/456 ---- [IMPORTANT] ==== The hotplugging feature only supports virtual machine operating systems with hotplugging operations. Example operating systems include: - Red Hat Enterprise Linux 6 - Red Hat Enterprise Linux 5 - Windows Server 2008 and - Windows Server 2003 ==== This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the NIC.
For example, to remove the NIC with id 456 from the virtual machine with id 123 send a request like this:
[source]
DELETE /ovirt-engine/api/vms/123/nics/456
[IMPORTANT]
The hotplugging feature only supports virtual machine operating systems with hotplugging operations. Example operating systems include:
- Red Hat Enterprise Linux 6
- Red Hat Enterprise Linux 5
- Windows Server 2008 and
- Windows Server 2003
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, nic, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the NIC. For example, to update the NIC having with `456` belonging to virtual the machine with id `123` send a request like this: [source] ---- PUT /ovirt-engine/api/vms/123/nics/456 ---- With a request body like this: [source,xml] ---- <nic> <name>mynic</name> <interface>e1000</interface> <vnic_profile id='789'/> </nic> ---- [IMPORTANT] ==== The hotplugging feature only supports virtual machine operating systems with hotplugging operations. Example operating systems include: - Red Hat Enterprise Linux 6 - Red Hat Enterprise Linux 5 - Windows Server 2008 and - Windows Server 2003 ==== """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(nic, headers, query, wait)
Updates the NIC.
For example, to update the NIC having with 456 belonging to virtual the machine with id 123 send a request
like this:
[source]
PUT /ovirt-engine/api/vms/123/nics/456
With a request body like this:
[source,xml]
[IMPORTANT]
The hotplugging feature only supports virtual machine operating systems with hotplugging operations. Example operating systems include:
- Red Hat Enterprise Linux 6
- Red Hat Enterprise Linux 5
- Windows Server 2008 and
- Windows Server 2003
View Source
def network_filter_parameters_service(self): """ Reference to the service that manages the network filter parameters of the NIC. A single top-level network filter may assigned to the NIC by the NIC's <<types/vnic_profile,vNIC Profile>>. """ return NicNetworkFilterParametersService(self._connection, '%s/networkfilterparameters' % self._path)
Reference to the service that manages the network filter parameters of the NIC.
A single top-level network filter may assigned to the NIC by the NIC's <
View Source
def reported_devices_service(self): """ """ return VmReportedDevicesService(self._connection, '%s/reporteddevices' % self._path)
View Source
def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'networkfilterparameters': return self.network_filter_parameters_service() if path.startswith('networkfilterparameters/'): return self.network_filter_parameters_service().service(path[24:]) if path == 'reporteddevices': return self.reported_devices_service() if path.startswith('reporteddevices/'): return self.reported_devices_service().service(path[16:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmNicsService(Service): """ """ def __init__(self, connection, path): super(VmNicsService, self).__init__(connection, path) self._nic_service = None def add( self, nic, headers=None, query=None, wait=True, **kwargs ): """ Adds a NIC to the virtual machine. The following example adds to the virtual machine `123` a network interface named `mynic` using `virtio` and the NIC profile `456`. [source] ---- POST /ovirt-engine/api/vms/123/nics ---- [source,xml] ---- <nic> <name>mynic</name> <interface>virtio</interface> <vnic_profile id="456"/> </nic> ---- The following example sends that request using `curl`: [source,bash] ---- curl \ --request POST \ --header "Version: 4" \ --header "Content-Type: application/xml" \ --header "Accept: application/xml" \ --user "admin@internal:mypassword" \ --cacert /etc/pki/ovirt-engine/ca.pem \ --data ' <nic> <name>mynic</name> <interface>virtio</interface> <vnic_profile id="456"/> </nic> ' \ https://myengine.example.com/ovirt-engine/api/vms/123/nics ---- [IMPORTANT] ==== The hotplugging feature only supports virtual machine operating systems with hotplugging operations. Example operating systems include: - Red Hat Enterprise Linux 6 - Red Hat Enterprise Linux 5 - Windows Server 2008 and - Windows Server 2003 ==== """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(nic, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of NICs of the virtual machine. The order of the returned list of NICs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def nic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmNicService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmNicsService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmNicsService, self).__init__(connection, path) self._nic_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, nic, headers=None, query=None, wait=True, **kwargs ): """ Adds a NIC to the virtual machine. The following example adds to the virtual machine `123` a network interface named `mynic` using `virtio` and the NIC profile `456`. [source] ---- POST /ovirt-engine/api/vms/123/nics ---- [source,xml] ---- <nic> <name>mynic</name> <interface>virtio</interface> <vnic_profile id="456"/> </nic> ---- The following example sends that request using `curl`: [source,bash] ---- curl \ --request POST \ --header "Version: 4" \ --header "Content-Type: application/xml" \ --header "Accept: application/xml" \ --user "admin@internal:mypassword" \ --cacert /etc/pki/ovirt-engine/ca.pem \ --data ' <nic> <name>mynic</name> <interface>virtio</interface> <vnic_profile id="456"/> </nic> ' \ https://myengine.example.com/ovirt-engine/api/vms/123/nics ---- [IMPORTANT] ==== The hotplugging feature only supports virtual machine operating systems with hotplugging operations. Example operating systems include: - Red Hat Enterprise Linux 6 - Red Hat Enterprise Linux 5 - Windows Server 2008 and - Windows Server 2003 ==== """ # Check the types of the parameters: Service._check_types([ ('nic', nic, types.Nic), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(nic, headers, query, wait)
Adds a NIC to the virtual machine.
The following example adds to the virtual machine 123 a network interface named mynic using virtio and the
NIC profile 456.
[source]
POST /ovirt-engine/api/vms/123/nics
[source,xml]
The following example sends that request using curl:
[source,bash]
curl --request POST --header "Version: 4" --header "Content-Type: application/xml" --header "Accept: application/xml" --user "admin@internal:mypassword" --cacert /etc/pki/ovirt-engine/ca.pem --data '
' https://myengine.example.com/ovirt-engine/api/vms/123/nics
[IMPORTANT]
The hotplugging feature only supports virtual machine operating systems with hotplugging operations. Example operating systems include:
- Red Hat Enterprise Linux 6
- Red Hat Enterprise Linux 5
- Windows Server 2008 and
- Windows Server 2003
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of NICs of the virtual machine. The order of the returned list of NICs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of NICs to return. If not specified all the NICs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of NICs of the virtual machine. The order of the returned list of NICs isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of NICs to return. If not specified all the NICs are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def nic_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmNicService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.nic_service(path) return self.nic_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmNumaNodeService(Service): """ """ def __init__(self, connection, path): super(VmNumaNodeService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a virtual NUMA node. An example of removing a virtual NUMA node: [source] ---- DELETE /ovirt-engine/api/vms/123/numanodes/456 ---- NOTE: It's required to remove the numa nodes from the highest index first. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, node, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a virtual NUMA node. An example of pinning a virtual NUMA node to a physical NUMA node on the host: [source] ---- PUT /ovirt-engine/api/vms/123/numanodes/456 ---- The request body should contain the following: [source,xml] ---- <vm_numa_node> <numa_node_pins> <numa_node_pin> <index>0</index> </numa_node_pin> </numa_node_pins> </vm_numa_node> ---- """ # Check the types of the parameters: Service._check_types([ ('node', node, types.VirtualNumaNode), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(node, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmNumaNodeService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmNumaNodeService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a virtual NUMA node. An example of removing a virtual NUMA node: [source] ---- DELETE /ovirt-engine/api/vms/123/numanodes/456 ---- NOTE: It's required to remove the numa nodes from the highest index first. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes a virtual NUMA node. An example of removing a virtual NUMA node:
[source]
DELETE /ovirt-engine/api/vms/123/numanodes/456
NOTE: It's required to remove the numa nodes from the highest index first.
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, node, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates a virtual NUMA node. An example of pinning a virtual NUMA node to a physical NUMA node on the host: [source] ---- PUT /ovirt-engine/api/vms/123/numanodes/456 ---- The request body should contain the following: [source,xml] ---- <vm_numa_node> <numa_node_pins> <numa_node_pin> <index>0</index> </numa_node_pin> </numa_node_pins> </vm_numa_node> ---- """ # Check the types of the parameters: Service._check_types([ ('node', node, types.VirtualNumaNode), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(node, headers, query, wait)
Updates a virtual NUMA node. An example of pinning a virtual NUMA node to a physical NUMA node on the host:
[source]
PUT /ovirt-engine/api/vms/123/numanodes/456
The request body should contain the following:
[source,xml]
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmNumaNodesService(Service): """ """ def __init__(self, connection, path): super(VmNumaNodesService, self).__init__(connection, path) self._node_service = None def add( self, node, headers=None, query=None, wait=True, **kwargs ): """ Creates a new virtual NUMA node for the virtual machine. An example of creating a NUMA node: [source] ---- POST /ovirt-engine/api/vms/c7ecd2dc/numanodes Accept: application/xml Content-type: application/xml ---- The request body can contain the following: [source,xml] ---- <vm_numa_node> <cpu> <cores> <core> <index>0</index> </core> </cores> </cpu> <index>0</index> <memory>1024</memory> <numa_tune_mode>strict</numa_tune_mode> </vm_numa_node> ---- """ # Check the types of the parameters: Service._check_types([ ('node', node, types.VirtualNumaNode), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(node, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists virtual NUMA nodes of a virtual machine. The order of the returned list of NUMA nodes isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of nodes to return. If not specified all the nodes are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def node_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmNumaNodeService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.node_service(path) return self.node_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmNumaNodesService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmNumaNodesService, self).__init__(connection, path) self._node_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, node, headers=None, query=None, wait=True, **kwargs ): """ Creates a new virtual NUMA node for the virtual machine. An example of creating a NUMA node: [source] ---- POST /ovirt-engine/api/vms/c7ecd2dc/numanodes Accept: application/xml Content-type: application/xml ---- The request body can contain the following: [source,xml] ---- <vm_numa_node> <cpu> <cores> <core> <index>0</index> </core> </cores> </cpu> <index>0</index> <memory>1024</memory> <numa_tune_mode>strict</numa_tune_mode> </vm_numa_node> ---- """ # Check the types of the parameters: Service._check_types([ ('node', node, types.VirtualNumaNode), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(node, headers, query, wait)
Creates a new virtual NUMA node for the virtual machine. An example of creating a NUMA node:
[source]
POST /ovirt-engine/api/vms/c7ecd2dc/numanodes Accept: application/xml
Content-type: application/xml
The request body can contain the following:
[source,xml]
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists virtual NUMA nodes of a virtual machine. The order of the returned list of NUMA nodes isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of nodes to return. If not specified all the nodes are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists virtual NUMA nodes of a virtual machine. The order of the returned list of NUMA nodes isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of nodes to return. If not specified all the nodes are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def node_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmNumaNodeService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.node_service(path) return self.node_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmPoolService(Service): """ A service to manage a virtual machines pool. """ def __init__(self, connection, path): super(VmPoolService, self).__init__(connection, path) self._permissions_service = None def allocate_vm( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation allocates a virtual machine in the virtual machine pool. [source] ---- POST /ovirt-engine/api/vmpools/123/allocatevm ---- The allocate virtual machine action does not take any action specific parameters, so the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the allocation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'allocatevm', None, headers, query, wait) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get the virtual machine pool. [source] ---- GET /ovirt-engine/api/vmpools/123 ---- You will get a XML response like that one: [source,xml] ---- <vm_pool id="123"> <actions>...</actions> <name>MyVmPool</name> <description>MyVmPool description</description> <link href="/ovirt-engine/api/vmpools/123/permissions" rel="permissions"/> <max_user_vms>1</max_user_vms> <prestarted_vms>0</prestarted_vms> <size>100</size> <stateful>false</stateful> <type>automatic</type> <use_latest_template_version>false</use_latest_template_version> <cluster id="123"/> <template id="123"/> <vm id="123">...</vm> ... </vm_pool> ---- This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a virtual machine pool. [source] ---- DELETE /ovirt-engine/api/vmpools/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, pool, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the virtual machine pool. [source] ---- PUT /ovirt-engine/api/vmpools/123 ---- The `name`, `description`, `size`, `prestarted_vms` and `max_user_vms` attributes can be updated after the virtual machine pool has been created. [source,xml] ---- <vmpool> <name>VM_Pool_B</name> <description>Virtual Machine Pool B</description> <size>3</size> <prestarted_vms>1</size> <max_user_vms>2</size> </vmpool> ---- This method supports the following parameters: `pool`:: The virtual machine pool that is being updated. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('pool', pool, types.VmPool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(pool, headers, query, wait) def permissions_service(self): """ Reference to a service managing the virtual machine pool assigned permissions. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmPoolService:%s' % self._path
A service to manage a virtual machines pool.
View Source
def __init__(self, connection, path): super(VmPoolService, self).__init__(connection, path) self._permissions_service = None
Creates a new service that will use the given connection and path.
View Source
def allocate_vm( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This operation allocates a virtual machine in the virtual machine pool. [source] ---- POST /ovirt-engine/api/vmpools/123/allocatevm ---- The allocate virtual machine action does not take any action specific parameters, so the request body should contain an empty `action`: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the allocation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'allocatevm', None, headers, query, wait)
This operation allocates a virtual machine in the virtual machine pool.
[source]
POST /ovirt-engine/api/vmpools/123/allocatevm
The allocate virtual machine action does not take any action specific parameters, so the request body should
contain an empty action:
[source,xml]
This method supports the following parameters:
async_:: Indicates if the allocation should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get the virtual machine pool. [source] ---- GET /ovirt-engine/api/vmpools/123 ---- You will get a XML response like that one: [source,xml] ---- <vm_pool id="123"> <actions>...</actions> <name>MyVmPool</name> <description>MyVmPool description</description> <link href="/ovirt-engine/api/vmpools/123/permissions" rel="permissions"/> <max_user_vms>1</max_user_vms> <prestarted_vms>0</prestarted_vms> <size>100</size> <stateful>false</stateful> <type>automatic</type> <use_latest_template_version>false</use_latest_template_version> <cluster id="123"/> <template id="123"/> <vm id="123">...</vm> ... </vm_pool> ---- This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get the virtual machine pool.
[source]
GET /ovirt-engine/api/vmpools/123
You will get a XML response like that one:
[source,xml]
This method supports the following parameters:
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a virtual machine pool. [source] ---- DELETE /ovirt-engine/api/vmpools/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes a virtual machine pool.
[source]
DELETE /ovirt-engine/api/vmpools/123
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, pool, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the virtual machine pool. [source] ---- PUT /ovirt-engine/api/vmpools/123 ---- The `name`, `description`, `size`, `prestarted_vms` and `max_user_vms` attributes can be updated after the virtual machine pool has been created. [source,xml] ---- <vmpool> <name>VM_Pool_B</name> <description>Virtual Machine Pool B</description> <size>3</size> <prestarted_vms>1</size> <max_user_vms>2</size> </vmpool> ---- This method supports the following parameters: `pool`:: The virtual machine pool that is being updated. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('pool', pool, types.VmPool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(pool, headers, query, wait)
Update the virtual machine pool.
[source]
PUT /ovirt-engine/api/vmpools/123
The name, description, size, prestarted_vms and max_user_vms
attributes can be updated after the virtual machine pool has been
created.
[source,xml]
This method supports the following parameters:
pool:: The virtual machine pool that is being updated.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def permissions_service(self): """ Reference to a service managing the virtual machine pool assigned permissions. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
Reference to a service managing the virtual machine pool assigned permissions.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmPoolsService(Service): """ Provides read-write access to virtual machines pools. """ def __init__(self, connection, path): super(VmPoolsService, self).__init__(connection, path) self._pool_service = None def add( self, pool, headers=None, query=None, wait=True, **kwargs ): """ Creates a new virtual machine pool. A new pool requires the `name`, `cluster` and `template` attributes. Identify the cluster and template with the `id` or `name` nested attributes: [source] ---- POST /ovirt-engine/api/vmpools ---- With the following body: [source,xml] ---- <vmpool> <name>mypool</name> <cluster id="123"/> <template id="456"/> </vmpool> ---- This method supports the following parameters: `pool`:: Pool to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('pool', pool, types.VmPool), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(pool, headers, query, wait) def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Get a list of available virtual machines pools. [source] ---- GET /ovirt-engine/api/vmpools ---- You will receive the following response: [source,xml] ---- <vm_pools> <vm_pool id="123"> ... </vm_pool> ... </vm_pools> ---- The order of the returned list of pools is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of pools to return. If this value is not specified, all of the pools are returned. `search`:: A query string used to restrict the returned pools. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def pool_service(self, id): """ Reference to the service that manages a specific virtual machine pool. """ Service._check_types([ ('id', id, str), ]) return VmPoolService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.pool_service(path) return self.pool_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmPoolsService:%s' % self._path
Provides read-write access to virtual machines pools.
View Source
def __init__(self, connection, path): super(VmPoolsService, self).__init__(connection, path) self._pool_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, pool, headers=None, query=None, wait=True, **kwargs ): """ Creates a new virtual machine pool. A new pool requires the `name`, `cluster` and `template` attributes. Identify the cluster and template with the `id` or `name` nested attributes: [source] ---- POST /ovirt-engine/api/vmpools ---- With the following body: [source,xml] ---- <vmpool> <name>mypool</name> <cluster id="123"/> <template id="456"/> </vmpool> ---- This method supports the following parameters: `pool`:: Pool to add. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('pool', pool, types.VmPool), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(pool, headers, query, wait)
Creates a new virtual machine pool.
A new pool requires the name, cluster and template attributes. Identify the cluster and template with the
id or name nested attributes:
[source]
POST /ovirt-engine/api/vmpools
With the following body:
[source,xml]
This method supports the following parameters:
pool:: Pool to add.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
list(
self,
case_sensitive=None,
filter=None,
follow=None,
max=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, case_sensitive=None, filter=None, follow=None, max=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Get a list of available virtual machines pools. [source] ---- GET /ovirt-engine/api/vmpools ---- You will receive the following response: [source,xml] ---- <vm_pools> <vm_pool id="123"> ... </vm_pool> ... </vm_pools> ---- The order of the returned list of pools is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `max`:: Sets the maximum number of pools to return. If this value is not specified, all of the pools are returned. `search`:: A query string used to restrict the returned pools. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('search', search, str), ]) # Build the URL: query = query or {} if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get a list of available virtual machines pools.
[source]
GET /ovirt-engine/api/vmpools
You will receive the following response:
[source,xml]
The order of the returned list of pools is guaranteed only if the sortby clause is included in the
search parameter.
This method supports the following parameters:
max:: Sets the maximum number of pools to return. If this value is not specified, all of the pools are returned.
search:: A query string used to restrict the returned pools.
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def pool_service(self, id): """ Reference to the service that manages a specific virtual machine pool. """ Service._check_types([ ('id', id, str), ]) return VmPoolService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages a specific virtual machine pool.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.pool_service(path) return self.pool_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmReportedDeviceService(Service): """ """ def __init__(self, connection, path): super(VmReportedDeviceService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmReportedDeviceService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmReportedDeviceService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmReportedDevicesService(Service): """ """ def __init__(self, connection, path): super(VmReportedDevicesService, self).__init__(connection, path) self._reported_device_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of reported devices of the virtual machine. The order of the returned list of devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of devices to return. If not specified all the devices are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def reported_device_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmReportedDeviceService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.reported_device_service(path) return self.reported_device_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmReportedDevicesService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmReportedDevicesService, self).__init__(connection, path) self._reported_device_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of reported devices of the virtual machine. The order of the returned list of devices isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of devices to return. If not specified all the devices are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of reported devices of the virtual machine. The order of the returned list of devices isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of devices to return. If not specified all the devices are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def reported_device_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmReportedDeviceService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.reported_device_service(path) return self.reported_device_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmSessionService(Service): """ """ def __init__(self, connection, path): super(VmSessionService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmSessionService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmSessionService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmSessionsService(Service): """ Provides information about virtual machine user sessions. """ def __init__(self, connection, path): super(VmSessionsService, self).__init__(connection, path) self._session_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all user sessions for this virtual machine. For example, to retrieve the session information for virtual machine `123` send a request like this: [source] ---- GET /ovirt-engine/api/vms/123/sessions ---- The response body will contain something like this: [source,xml] ---- <sessions> <session href="/ovirt-engine/api/vms/123/sessions/456" id="456"> <console_user>true</console_user> <ip> <address>192.168.122.1</address> </ip> <user href="/ovirt-engine/api/users/789" id="789"/> <vm href="/ovirt-engine/api/vms/123" id="123"/> </session> ... </sessions> ---- The order of the returned list of sessions isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of sessions to return. If not specified all the sessions are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def session_service(self, id): """ Reference to the service that manages a specific session. """ Service._check_types([ ('id', id, str), ]) return VmSessionService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.session_service(path) return self.session_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmSessionsService:%s' % self._path
Provides information about virtual machine user sessions.
View Source
def __init__(self, connection, path): super(VmSessionsService, self).__init__(connection, path) self._session_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Lists all user sessions for this virtual machine. For example, to retrieve the session information for virtual machine `123` send a request like this: [source] ---- GET /ovirt-engine/api/vms/123/sessions ---- The response body will contain something like this: [source,xml] ---- <sessions> <session href="/ovirt-engine/api/vms/123/sessions/456" id="456"> <console_user>true</console_user> <ip> <address>192.168.122.1</address> </ip> <user href="/ovirt-engine/api/users/789" id="789"/> <vm href="/ovirt-engine/api/vms/123" id="123"/> </session> ... </sessions> ---- The order of the returned list of sessions isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of sessions to return. If not specified all the sessions are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Lists all user sessions for this virtual machine.
For example, to retrieve the session information for virtual machine 123 send a request like this:
[source]
GET /ovirt-engine/api/vms/123/sessions
The response body will contain something like this:
[source,xml]
The order of the returned list of sessions isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of sessions to return. If not specified all the sessions are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def session_service(self, id): """ Reference to the service that manages a specific session. """ Service._check_types([ ('id', id, str), ]) return VmSessionService(self._connection, '%s/%s' % (self._path, id))
Reference to the service that manages a specific session.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.session_service(path) return self.session_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmWatchdogService(Service): """ A service managing a watchdog on virtual machines. """ def __init__(self, connection, path): super(VmWatchdogService, self).__init__(connection, path) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about the watchdog. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the watchdog from the virtual machine. For example, to remove a watchdog from a virtual machine, send a request like this: [source] ---- DELETE /ovirt-engine/api/vms/123/watchdogs/00000000-0000-0000-0000-000000000000 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, watchdog, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the information about the watchdog. You can update the information using `action` and `model` elements. For example, to update a watchdog, send a request like this: [source] ---- PUT /ovirt-engine/api/vms/123/watchdogs <watchdog> <action>reset</action> </watchdog> ---- with response body: [source,xml] ---- <watchdog href="/ovirt-engine/api/vms/123/watchdogs/00000000-0000-0000-0000-000000000000" id="00000000-0000-0000-0000-000000000000"> <vm href="/ovirt-engine/api/vms/123" id="123"/> <action>reset</action> <model>i6300esb</model> </watchdog> ---- This method supports the following parameters: `watchdog`:: The information about the watchdog. The request data must contain at least one of `model` and `action` elements. The response data contains complete information about the updated watchdog. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(watchdog, headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VmWatchdogService:%s' % self._path
A service managing a watchdog on virtual machines.
View Source
def __init__(self, connection, path): super(VmWatchdogService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the information about the watchdog. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the information about the watchdog.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the watchdog from the virtual machine. For example, to remove a watchdog from a virtual machine, send a request like this: [source] ---- DELETE /ovirt-engine/api/vms/123/watchdogs/00000000-0000-0000-0000-000000000000 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the watchdog from the virtual machine. For example, to remove a watchdog from a virtual machine, send a request like this:
[source]
DELETE /ovirt-engine/api/vms/123/watchdogs/00000000-0000-0000-0000-000000000000
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, watchdog, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the information about the watchdog. You can update the information using `action` and `model` elements. For example, to update a watchdog, send a request like this: [source] ---- PUT /ovirt-engine/api/vms/123/watchdogs <watchdog> <action>reset</action> </watchdog> ---- with response body: [source,xml] ---- <watchdog href="/ovirt-engine/api/vms/123/watchdogs/00000000-0000-0000-0000-000000000000" id="00000000-0000-0000-0000-000000000000"> <vm href="/ovirt-engine/api/vms/123" id="123"/> <action>reset</action> <model>i6300esb</model> </watchdog> ---- This method supports the following parameters: `watchdog`:: The information about the watchdog. The request data must contain at least one of `model` and `action` elements. The response data contains complete information about the updated watchdog. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(watchdog, headers, query, wait)
Updates the information about the watchdog.
You can update the information using action and model elements.
For example, to update a watchdog, send a request like this:
[source]
PUT /ovirt-engine/api/vms/123/watchdogs
with response body:
[source,xml]
This method supports the following parameters:
watchdog:: The information about the watchdog.
The request data must contain at least one of model and action
elements. The response data contains complete information about the
updated watchdog.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmWatchdogsService(Service): """ Lists the watchdogs of a virtual machine. """ def __init__(self, connection, path): super(VmWatchdogsService, self).__init__(connection, path) self._watchdog_service = None def add( self, watchdog, headers=None, query=None, wait=True, **kwargs ): """ Adds new watchdog to the virtual machine. For example, to add a watchdog to a virtual machine, send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/watchdogs <watchdog> <action>poweroff</action> <model>i6300esb</model> </watchdog> ---- with response body: [source,xml] ---- <watchdog href="/ovirt-engine/api/vms/123/watchdogs/00000000-0000-0000-0000-000000000000" id="00000000-0000-0000-0000-000000000000"> <vm href="/ovirt-engine/api/vms/123" id="123"/> <action>poweroff</action> <model>i6300esb</model> </watchdog> ---- This method supports the following parameters: `watchdog`:: The information about the watchdog. The request data must contain `model` element (such as `i6300esb`) and `action` element (one of `none`, `reset`, `poweroff`, `dump`, `pause`). The response data additionally contains references to the added watchdog and to the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(watchdog, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ The list of watchdogs of the virtual machine. The order of the returned list of watchdogs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of watchdogs to return. If not specified all the watchdogs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def watchdog_service(self, id): """ Returns a reference to the service that manages a specific watchdog. """ Service._check_types([ ('id', id, str), ]) return VmWatchdogService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.watchdog_service(path) return self.watchdog_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmWatchdogsService:%s' % self._path
Lists the watchdogs of a virtual machine.
View Source
def __init__(self, connection, path): super(VmWatchdogsService, self).__init__(connection, path) self._watchdog_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, watchdog, headers=None, query=None, wait=True, **kwargs ): """ Adds new watchdog to the virtual machine. For example, to add a watchdog to a virtual machine, send a request like this: [source] ---- POST /ovirt-engine/api/vms/123/watchdogs <watchdog> <action>poweroff</action> <model>i6300esb</model> </watchdog> ---- with response body: [source,xml] ---- <watchdog href="/ovirt-engine/api/vms/123/watchdogs/00000000-0000-0000-0000-000000000000" id="00000000-0000-0000-0000-000000000000"> <vm href="/ovirt-engine/api/vms/123" id="123"/> <action>poweroff</action> <model>i6300esb</model> </watchdog> ---- This method supports the following parameters: `watchdog`:: The information about the watchdog. The request data must contain `model` element (such as `i6300esb`) and `action` element (one of `none`, `reset`, `poweroff`, `dump`, `pause`). The response data additionally contains references to the added watchdog and to the virtual machine. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('watchdog', watchdog, types.Watchdog), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(watchdog, headers, query, wait)
Adds new watchdog to the virtual machine. For example, to add a watchdog to a virtual machine, send a request like this:
[source]
POST /ovirt-engine/api/vms/123/watchdogs
with response body:
[source,xml]
This method supports the following parameters:
watchdog:: The information about the watchdog.
The request data must contain model element (such as i6300esb) and action element
(one of none, reset, poweroff, dump, pause). The response data additionally
contains references to the added watchdog and to the virtual machine.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ The list of watchdogs of the virtual machine. The order of the returned list of watchdogs isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of watchdogs to return. If not specified all the watchdogs are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
The list of watchdogs of the virtual machine. The order of the returned list of watchdogs isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of watchdogs to return. If not specified all the watchdogs are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def watchdog_service(self, id): """ Returns a reference to the service that manages a specific watchdog. """ Service._check_types([ ('id', id, str), ]) return VmWatchdogService(self._connection, '%s/%s' % (self._path, id))
Returns a reference to the service that manages a specific watchdog.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.watchdog_service(path) return self.watchdog_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VmsService(Service): """ """ def __init__(self, connection, path): super(VmsService, self).__init__(connection, path) self._vm_service = None def add( self, vm, auto_pinning_policy=None, clone=None, clone_permissions=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ Creates a new virtual machine. The virtual machine can be created in different ways: - From a template. In this case the identifier or name of the template must be provided. For example, using a plain shell script and XML: [source,bash] ---- #!/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 ' <vm> <name>myvm</name> <template> <name>Blank</name> </template> <cluster> <name>mycluster</name> </cluster> </vm> ' \ "${url}/vms" ---- - From a snapshot. In this case the identifier of the snapshot has to be provided. For example, using a plain shel script and XML: [source,bash] ---- #!/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 "Content-Type: application/xml" \ --header "Accept: application/xml" \ --data ' <vm> <name>myvm</name> <snapshots> <snapshot id="266742a5-6a65-483c-816d-d2ce49746680"/> </snapshots> <cluster> <name>mycluster</name> </cluster> </vm> ' \ "${url}/vms" ---- When creating a virtual machine from a template or from a snapshot it is usually useful to explicitly indicate in what storage domain to create the disks for the virtual machine. If the virtual machine is created from a template then this is achieved passing a set of `disk_attachment` elements that indicate the mapping: [source,xml] ---- <vm> ... <disk_attachments> <disk_attachment> <disk id="8d4bd566-6c86-4592-a4a7-912dbf93c298"> <storage_domains> <storage_domain id="9cb6cb0a-cf1d-41c2-92ca-5a6d665649c9"/> </storage_domains> </disk> <disk_attachment> </disk_attachments> </vm> ---- When the virtual machine is created from a snapshot this set of disks is slightly different, it uses the `image_id` attribute instead of `id`. [source,xml] ---- <vm> ... <disk_attachments> <disk_attachment> <disk> <image_id>8d4bd566-6c86-4592-a4a7-912dbf93c298</image_id> <storage_domains> <storage_domain id="9cb6cb0a-cf1d-41c2-92ca-5a6d665649c9"/> </storage_domains> </disk> <disk_attachment> </disk_attachments> </vm> ---- It is possible to specify additional virtual machine parameters in the XML description, e.g. a virtual machine of `desktop` type, with 2 GiB of RAM and additional description can be added sending a request body like the following: [source,xml] ---- <vm> <name>myvm</name> <description>My Desktop Virtual Machine</description> <type>desktop</type> <memory>2147483648</memory> ... </vm> ---- A bootable CDROM device can be set like this: [source,xml] ---- <vm> ... <os> <boot dev="cdrom"/> </os> </vm> ---- In order to boot from CDROM, you first need to insert a disk, as described in the <<services/vm_cdrom, CDROM service>>. Then booting from that CDROM can be specified using the `os.boot.devices` attribute: [source,xml] ---- <vm> ... <os> <boot> <devices> <device>cdrom</device> </devices> </boot> </os> </vm> ---- In all cases the name or identifier of the cluster where the virtual machine will be created is mandatory. """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('auto_pinning_policy', auto_pinning_policy, types.AutoPinningPolicy), ('clone', clone, bool), ('clone_permissions', clone_permissions, bool), ('filter', filter, bool), ]) # Build the URL: query = query or {} if auto_pinning_policy is not None: query['auto_pinning_policy'] = auto_pinning_policy if clone is not None: clone = Writer.render_boolean(clone) query['clone'] = clone if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait) def add_from_configuration( self, vm, auto_pinning_policy=None, clone=None, clone_permissions=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ add a virtual machine to the system from a configuration - requires the configuration type and the configuration data """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('auto_pinning_policy', auto_pinning_policy, types.AutoPinningPolicy), ('clone', clone, bool), ('clone_permissions', clone_permissions, bool), ('filter', filter, bool), ]) # Build the URL: query = query or {} if auto_pinning_policy is not None: query['auto_pinning_policy'] = auto_pinning_policy if clone is not None: clone = Writer.render_boolean(clone) query['clone'] = clone if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait) def add_from_scratch( self, vm, auto_pinning_policy=None, clone=None, clone_permissions=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ add a virtual machine to the system from scratch """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('auto_pinning_policy', auto_pinning_policy, types.AutoPinningPolicy), ('clone', clone, bool), ('clone_permissions', clone_permissions, bool), ('filter', filter, bool), ]) # Build the URL: query = query or {} if auto_pinning_policy is not None: query['auto_pinning_policy'] = auto_pinning_policy if clone is not None: clone = Writer.render_boolean(clone) query['clone'] = clone if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait) def add_from_snapshot( self, vm, auto_pinning_policy=None, clone=None, clone_permissions=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ add a virtual machine to the system by cloning from a snapshot """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('auto_pinning_policy', auto_pinning_policy, types.AutoPinningPolicy), ('clone', clone, bool), ('clone_permissions', clone_permissions, bool), ('filter', filter, bool), ]) # Build the URL: query = query or {} if auto_pinning_policy is not None: query['auto_pinning_policy'] = auto_pinning_policy if clone is not None: clone = Writer.render_boolean(clone) query['clone'] = clone if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait) def list( self, all_content=None, case_sensitive=None, filter=None, follow=None, max=None, ovf_as_ova=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of virtual machines of the system. The order of the returned list of virtual machines is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `search`:: A query string used to restrict the returned virtual machines. `max`:: The maximum number of results to return. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `all_content`:: Indicates if all the attributes of the virtual machines should be included in the response. By default the following attributes are excluded: - `console` - `initialization.configuration.data` - The OVF document describing the virtual machine. - `rng_source` - `soundcard` - `virtio_scsi` For example, to retrieve the complete representation of the virtual machines send a request like this: .... GET /ovirt-engine/api/vms?all_content=true .... NOTE: The reason for not including these attributes is performance: they are seldom used and they require additional queries to the database. So try to use the this parameter only when it is really needed. `ovf_as_ova`:: Indicates if the results should expose the OVF as it appears in OVA files of that VM. The OVF document describing the virtual machine. This parameter will work only when all_content=True is set. The OVF will be presented in `initialization.configuration.data`. For example: [source] ---- GET /vms?all_content=true&ovf_as_ova=true ---- `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('ovf_as_ova', ovf_as_ova, bool), ('search', search, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if ovf_as_ova is not None: ovf_as_ova = Writer.render_boolean(ovf_as_ova) query['ovf_as_ova'] = ovf_as_ova if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait) def vm_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.vm_service(path) return self.vm_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VmsService:%s' % self._path
View Source
def __init__(self, connection, path): super(VmsService, self).__init__(connection, path) self._vm_service = None
Creates a new service that will use the given connection and path.
#
def
add(
self,
vm,
auto_pinning_policy=None,
clone=None,
clone_permissions=None,
filter=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def add( self, vm, auto_pinning_policy=None, clone=None, clone_permissions=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ Creates a new virtual machine. The virtual machine can be created in different ways: - From a template. In this case the identifier or name of the template must be provided. For example, using a plain shell script and XML: [source,bash] ---- #!/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 ' <vm> <name>myvm</name> <template> <name>Blank</name> </template> <cluster> <name>mycluster</name> </cluster> </vm> ' \ "${url}/vms" ---- - From a snapshot. In this case the identifier of the snapshot has to be provided. For example, using a plain shel script and XML: [source,bash] ---- #!/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 "Content-Type: application/xml" \ --header "Accept: application/xml" \ --data ' <vm> <name>myvm</name> <snapshots> <snapshot id="266742a5-6a65-483c-816d-d2ce49746680"/> </snapshots> <cluster> <name>mycluster</name> </cluster> </vm> ' \ "${url}/vms" ---- When creating a virtual machine from a template or from a snapshot it is usually useful to explicitly indicate in what storage domain to create the disks for the virtual machine. If the virtual machine is created from a template then this is achieved passing a set of `disk_attachment` elements that indicate the mapping: [source,xml] ---- <vm> ... <disk_attachments> <disk_attachment> <disk id="8d4bd566-6c86-4592-a4a7-912dbf93c298"> <storage_domains> <storage_domain id="9cb6cb0a-cf1d-41c2-92ca-5a6d665649c9"/> </storage_domains> </disk> <disk_attachment> </disk_attachments> </vm> ---- When the virtual machine is created from a snapshot this set of disks is slightly different, it uses the `image_id` attribute instead of `id`. [source,xml] ---- <vm> ... <disk_attachments> <disk_attachment> <disk> <image_id>8d4bd566-6c86-4592-a4a7-912dbf93c298</image_id> <storage_domains> <storage_domain id="9cb6cb0a-cf1d-41c2-92ca-5a6d665649c9"/> </storage_domains> </disk> <disk_attachment> </disk_attachments> </vm> ---- It is possible to specify additional virtual machine parameters in the XML description, e.g. a virtual machine of `desktop` type, with 2 GiB of RAM and additional description can be added sending a request body like the following: [source,xml] ---- <vm> <name>myvm</name> <description>My Desktop Virtual Machine</description> <type>desktop</type> <memory>2147483648</memory> ... </vm> ---- A bootable CDROM device can be set like this: [source,xml] ---- <vm> ... <os> <boot dev="cdrom"/> </os> </vm> ---- In order to boot from CDROM, you first need to insert a disk, as described in the <<services/vm_cdrom, CDROM service>>. Then booting from that CDROM can be specified using the `os.boot.devices` attribute: [source,xml] ---- <vm> ... <os> <boot> <devices> <device>cdrom</device> </devices> </boot> </os> </vm> ---- In all cases the name or identifier of the cluster where the virtual machine will be created is mandatory. """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('auto_pinning_policy', auto_pinning_policy, types.AutoPinningPolicy), ('clone', clone, bool), ('clone_permissions', clone_permissions, bool), ('filter', filter, bool), ]) # Build the URL: query = query or {} if auto_pinning_policy is not None: query['auto_pinning_policy'] = auto_pinning_policy if clone is not None: clone = Writer.render_boolean(clone) query['clone'] = clone if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait)
Creates a new virtual machine. The virtual machine can be created in different ways:
- From a template. In this case the identifier or name of the template must be provided. For example, using a plain shell script and XML:
[source,bash]
!/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 '
' "${url}/vms"
- From a snapshot. In this case the identifier of the snapshot has to be provided. For example, using a plain
shel script and XML:
[source,bash]
!/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 "Content-Type: application/xml" --header "Accept: application/xml" --data '
' "${url}/vms"
When creating a virtual machine from a template or from a snapshot it is usually useful to explicitly indicate
in what storage domain to create the disks for the virtual machine. If the virtual machine is created from
a template then this is achieved passing a set of disk_attachment elements that indicate the mapping:
[source,xml]
When the virtual machine is created from a snapshot this set of disks is slightly different, it uses the
image_id attribute instead of id.
[source,xml]
It is possible to specify additional virtual machine parameters in the XML description, e.g. a virtual machine
of desktop type, with 2 GiB of RAM and additional description can be added sending a request body like the
following:
[source,xml]
A bootable CDROM device can be set like this:
[source,xml]
In order to boot from CDROM, you first need to insert a disk, as described in the
<os.boot.devices
attribute:
[source,xml]
In all cases the name or identifier of the cluster where the virtual machine will be created is mandatory.
#
def
add_from_configuration(
self,
vm,
auto_pinning_policy=None,
clone=None,
clone_permissions=None,
filter=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def add_from_configuration( self, vm, auto_pinning_policy=None, clone=None, clone_permissions=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ add a virtual machine to the system from a configuration - requires the configuration type and the configuration data """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('auto_pinning_policy', auto_pinning_policy, types.AutoPinningPolicy), ('clone', clone, bool), ('clone_permissions', clone_permissions, bool), ('filter', filter, bool), ]) # Build the URL: query = query or {} if auto_pinning_policy is not None: query['auto_pinning_policy'] = auto_pinning_policy if clone is not None: clone = Writer.render_boolean(clone) query['clone'] = clone if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait)
add a virtual machine to the system from a configuration - requires the configuration type and the configuration data
#
def
add_from_scratch(
self,
vm,
auto_pinning_policy=None,
clone=None,
clone_permissions=None,
filter=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def add_from_scratch( self, vm, auto_pinning_policy=None, clone=None, clone_permissions=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ add a virtual machine to the system from scratch """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('auto_pinning_policy', auto_pinning_policy, types.AutoPinningPolicy), ('clone', clone, bool), ('clone_permissions', clone_permissions, bool), ('filter', filter, bool), ]) # Build the URL: query = query or {} if auto_pinning_policy is not None: query['auto_pinning_policy'] = auto_pinning_policy if clone is not None: clone = Writer.render_boolean(clone) query['clone'] = clone if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait)
add a virtual machine to the system from scratch
#
def
add_from_snapshot(
self,
vm,
auto_pinning_policy=None,
clone=None,
clone_permissions=None,
filter=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def add_from_snapshot( self, vm, auto_pinning_policy=None, clone=None, clone_permissions=None, filter=None, headers=None, query=None, wait=True, **kwargs ): """ add a virtual machine to the system by cloning from a snapshot """ # Check the types of the parameters: Service._check_types([ ('vm', vm, types.Vm), ('auto_pinning_policy', auto_pinning_policy, types.AutoPinningPolicy), ('clone', clone, bool), ('clone_permissions', clone_permissions, bool), ('filter', filter, bool), ]) # Build the URL: query = query or {} if auto_pinning_policy is not None: query['auto_pinning_policy'] = auto_pinning_policy if clone is not None: clone = Writer.render_boolean(clone) query['clone'] = clone if clone_permissions is not None: clone_permissions = Writer.render_boolean(clone_permissions) query['clone_permissions'] = clone_permissions if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter # Send the request and wait for the response: return self._internal_add(vm, headers, query, wait)
add a virtual machine to the system by cloning from a snapshot
#
def
list(
self,
all_content=None,
case_sensitive=None,
filter=None,
follow=None,
max=None,
ovf_as_ova=None,
search=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, all_content=None, case_sensitive=None, filter=None, follow=None, max=None, ovf_as_ova=None, search=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of virtual machines of the system. The order of the returned list of virtual machines is guaranteed only if the `sortby` clause is included in the `search` parameter. This method supports the following parameters: `search`:: A query string used to restrict the returned virtual machines. `max`:: The maximum number of results to return. `case_sensitive`:: Indicates if the search performed using the `search` parameter should be performed taking case into account. The default value is `true`, which means that case is taken into account. If you want to search ignoring case set it to `false`. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `all_content`:: Indicates if all the attributes of the virtual machines should be included in the response. By default the following attributes are excluded: - `console` - `initialization.configuration.data` - The OVF document describing the virtual machine. - `rng_source` - `soundcard` - `virtio_scsi` For example, to retrieve the complete representation of the virtual machines send a request like this: .... GET /ovirt-engine/api/vms?all_content=true .... NOTE: The reason for not including these attributes is performance: they are seldom used and they require additional queries to the database. So try to use the this parameter only when it is really needed. `ovf_as_ova`:: Indicates if the results should expose the OVF as it appears in OVA files of that VM. The OVF document describing the virtual machine. This parameter will work only when all_content=True is set. The OVF will be presented in `initialization.configuration.data`. For example: [source] ---- GET /vms?all_content=true&ovf_as_ova=true ---- `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('case_sensitive', case_sensitive, bool), ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ('ovf_as_ova', ovf_as_ova, bool), ('search', search, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if case_sensitive is not None: case_sensitive = Writer.render_boolean(case_sensitive) query['case_sensitive'] = case_sensitive if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max if ovf_as_ova is not None: ovf_as_ova = Writer.render_boolean(ovf_as_ova) query['ovf_as_ova'] = ovf_as_ova if search is not None: query['search'] = search # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of virtual machines of the system.
The order of the returned list of virtual machines is guaranteed only if the sortby clause is included
in the search parameter.
This method supports the following parameters:
search:: A query string used to restrict the returned virtual machines.
max:: The maximum number of results to return.
case_sensitive:: Indicates if the search performed using the search parameter should be performed taking case into
account. The default value is true, which means that case is taken into account. If you want to search
ignoring case set it to false.
filter:: Indicates if the results should be filtered according to the permissions of the user.
all_content:: Indicates if all the attributes of the virtual machines should be included in the response.
By default the following attributes are excluded:
consoleinitialization.configuration.data- The OVF document describing the virtual machine.rng_sourcesoundcardvirtio_scsiFor example, to retrieve the complete representation of the virtual machines send a request like this: .... GET /ovirt-engine/api/vms?all_content=true .... NOTE: The reason for not including these attributes is performance: they are seldom used and they require additional queries to the database. So try to use the this parameter only when it is really needed.
ovf_as_ova:: Indicates if the results should expose the OVF as it appears in OVA files of that VM. The OVF document
describing the virtual machine. This parameter will work only when all_content=True is set.
The OVF will be presented in initialization.configuration.data.
For example:
[source]
GET /vms?all_content=true&ovf_as_ova=true
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def vm_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VmService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.vm_service(path) return self.vm_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VnicProfileService(Service): """ This service manages a vNIC profile. """ def __init__(self, connection, path): super(VnicProfileService, self).__init__(connection, path) self._permissions_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves details about a vNIC profile. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the vNIC profile. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def update( self, profile, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates details of a vNIC profile. This method supports the following parameters: `profile`:: The vNIC profile that is being updated. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.VnicProfile), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(profile, headers, query, wait) def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'VnicProfileService:%s' % self._path
This service manages a vNIC profile.
View Source
def __init__(self, connection, path): super(VnicProfileService, self).__init__(connection, path) self._permissions_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves details about a vNIC profile. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves details about a vNIC profile.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the vNIC profile. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the vNIC profile.
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, profile, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates details of a vNIC profile. This method supports the following parameters: `profile`:: The vNIC profile that is being updated. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.VnicProfile), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(profile, headers, query, wait)
Updates details of a vNIC profile.
This method supports the following parameters:
profile:: The vNIC profile that is being updated.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def permissions_service(self): """ """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class VnicProfilesService(Service): """ This service manages the collection of all vNIC profiles. """ def __init__(self, connection, path): super(VnicProfilesService, self).__init__(connection, path) self._profile_service = None def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a vNIC profile. For example to add vNIC profile `123` to network `456` send a request to: [source] ---- POST /ovirt-engine/api/networks/456/vnicprofiles ---- With the following body: [source,xml] ---- <vnic_profile id="123"> <name>new_vNIC_name</name> <pass_through> <mode>disabled</mode> </pass_through> <port_mirroring>false</port_mirroring> </vnic_profile> ---- Please note that there is a default network filter to each VNIC profile. For more details of how the default network filter is calculated please refer to the documentation in <<services/network_filters,NetworkFilters>>. NOTE: The automatically created vNIC profile for the external network will be without network filter. The output of creating a new VNIC profile depends in the body arguments that were given. In case no network filter was given, the default network filter will be configured. For example: [source,xml] ---- <vnic_profile href="/ovirt-engine/api/vnicprofiles/123" id="123"> <name>new_vNIC_name</name> <link href="/ovirt-engine/api/vnicprofiles/123/permissions" rel="permissions"/> <pass_through> <mode>disabled</mode> </pass_through> <port_mirroring>false</port_mirroring> <network href="/ovirt-engine/api/networks/456" id="456"/> <network_filter href="/ovirt-engine/api/networkfilters/789" id="789"/> </vnic_profile> ---- In case an empty network filter was given, no network filter will be configured for the specific VNIC profile regardless of the VNIC profile's default network filter. For example: [source,xml] ---- <vnic_profile> <name>no_network_filter</name> <network_filter/> </vnic_profile> ---- In case that a specific valid network filter id was given, the VNIC profile will be configured with the given network filter regardless of the VNIC profiles's default network filter. For example: [source,xml] ---- <vnic_profile> <name>user_choice_network_filter</name> <network_filter id= "0000001b-001b-001b-001b-0000000001d5"/> </vnic_profile> ---- This method supports the following parameters: `profile`:: The vNIC profile that is being added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.VnicProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait) def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all vNIC profiles. The order of the returned list of vNIC profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VnicProfileService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'VnicProfilesService:%s' % self._path
This service manages the collection of all vNIC profiles.
View Source
def __init__(self, connection, path): super(VnicProfilesService, self).__init__(connection, path) self._profile_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, profile, headers=None, query=None, wait=True, **kwargs ): """ Add a vNIC profile. For example to add vNIC profile `123` to network `456` send a request to: [source] ---- POST /ovirt-engine/api/networks/456/vnicprofiles ---- With the following body: [source,xml] ---- <vnic_profile id="123"> <name>new_vNIC_name</name> <pass_through> <mode>disabled</mode> </pass_through> <port_mirroring>false</port_mirroring> </vnic_profile> ---- Please note that there is a default network filter to each VNIC profile. For more details of how the default network filter is calculated please refer to the documentation in <<services/network_filters,NetworkFilters>>. NOTE: The automatically created vNIC profile for the external network will be without network filter. The output of creating a new VNIC profile depends in the body arguments that were given. In case no network filter was given, the default network filter will be configured. For example: [source,xml] ---- <vnic_profile href="/ovirt-engine/api/vnicprofiles/123" id="123"> <name>new_vNIC_name</name> <link href="/ovirt-engine/api/vnicprofiles/123/permissions" rel="permissions"/> <pass_through> <mode>disabled</mode> </pass_through> <port_mirroring>false</port_mirroring> <network href="/ovirt-engine/api/networks/456" id="456"/> <network_filter href="/ovirt-engine/api/networkfilters/789" id="789"/> </vnic_profile> ---- In case an empty network filter was given, no network filter will be configured for the specific VNIC profile regardless of the VNIC profile's default network filter. For example: [source,xml] ---- <vnic_profile> <name>no_network_filter</name> <network_filter/> </vnic_profile> ---- In case that a specific valid network filter id was given, the VNIC profile will be configured with the given network filter regardless of the VNIC profiles's default network filter. For example: [source,xml] ---- <vnic_profile> <name>user_choice_network_filter</name> <network_filter id= "0000001b-001b-001b-001b-0000000001d5"/> </vnic_profile> ---- This method supports the following parameters: `profile`:: The vNIC profile that is being added. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('profile', profile, types.VnicProfile), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(profile, headers, query, wait)
Add a vNIC profile.
For example to add vNIC profile 123 to network 456 send a request to:
[source]
POST /ovirt-engine/api/networks/456/vnicprofiles
With the following body:
[source,xml]
Please note that there is a default network filter to each VNIC profile.
For more details of how the default network filter is calculated please refer to
the documentation in <
[source,xml]
In case an empty network filter was given, no network filter will be configured for the specific VNIC profile regardless of the VNIC profile's default network filter. For example:
[source,xml]
In case that a specific valid network filter id was given, the VNIC profile will be configured with the given network filter regardless of the VNIC profiles's default network filter. For example:
[source,xml]
This method supports the following parameters:
profile:: The vNIC profile that is being added.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ List all vNIC profiles. The order of the returned list of vNIC profiles isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of profiles to return. If not specified all the profiles are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
List all vNIC profiles. The order of the returned list of vNIC profiles isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of profiles to return. If not specified all the profiles are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def profile_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return VnicProfileService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.profile_service(path) return self.profile_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class WeightService(Service): """ """ def __init__(self, connection, path): super(WeightService, self).__init__(connection, path) def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'WeightService:%s' % self._path
View Source
def __init__(self, connection, path): super(WeightService, self).__init__(connection, path)
Creates a new service that will use the given connection and path.
View Source
def get( self, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class WeightsService(Service): """ """ def __init__(self, connection, path): super(WeightsService, self).__init__(connection, path) self._weight_service = None def add( self, weight, headers=None, query=None, wait=True, **kwargs ): """ Add a weight to a specified user defined scheduling policy. """ # Check the types of the parameters: Service._check_types([ ('weight', weight, types.Weight), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(weight, headers, query, wait) def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of weights. The order of the returned list of weights isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of weights to return. If not specified all the weights are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def weight_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return WeightService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.weight_service(path) return self.weight_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'WeightsService:%s' % self._path
View Source
def __init__(self, connection, path): super(WeightsService, self).__init__(connection, path) self._weight_service = None
Creates a new service that will use the given connection and path.
View Source
def add( self, weight, headers=None, query=None, wait=True, **kwargs ): """ Add a weight to a specified user defined scheduling policy. """ # Check the types of the parameters: Service._check_types([ ('weight', weight, types.Weight), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_add(weight, headers, query, wait)
Add a weight to a specified user defined scheduling policy.
#
def
list(
self,
filter=None,
follow=None,
max=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def list( self, filter=None, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Returns the list of weights. The order of the returned list of weights isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of weights to return. If not specified all the weights are returned. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('filter', filter, bool), ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Returns the list of weights. The order of the returned list of weights isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of weights to return. If not specified all the weights are returned.
filter:: Indicates if the results should be filtered according to the permissions of the user.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def weight_service(self, id): """ """ Service._check_types([ ('id', id, str), ]) return WeightService(self._connection, '%s/%s' % (self._path, id))
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.weight_service(path) return self.weight_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class AttachedStorageDomainDiskService(MeasurableService): """ Manages a single disk available in a storage domain attached to a data center. IMPORTANT: Since version 4.2 of the engine this service is intended only to list disks available in the storage domain, and to register unregistered disks. All the other operations, like copying a disk, moving a disk, etc, have been deprecated and will be removed in the future. To perform those operations use the <<services/disks, service that manages all the disks of the system>>, or the <<services/disk, service that manages an specific disk>>. """ def __init__(self, connection, path): super(AttachedStorageDomainDiskService, self).__init__(connection, path) self._permissions_service = None self._statistics_service = None def copy( self, disk=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Copies a disk to the specified storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To copy a disk use the <<services/disk/methods/copy, copy>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: Description of the resulting disk. `storage_domain`:: The storage domain where the new disk will be created. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( disk=disk, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait) def export( self, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a disk to an export storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To export a disk use the <<services/disk/methods/export, export>> operation of the service that manages that disk. This method supports the following parameters: `storage_domain`:: The export storage domain where the disk should be exported to. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def move( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Moves a disk to another storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To move a disk use the <<services/disk/methods/move, move>> operation of the service that manages that disk. This method supports the following parameters: `storage_domain`:: The storage domain where the disk will be moved to. `async_`:: Indicates if the move should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait) def register( self, headers=None, query=None, wait=True, **kwargs ): """ Registers an unregistered disk. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'register', None, headers, query, wait) def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes a disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To remove a disk use the <<services/disk/methods/remove, remove>> operation of the service that manages that disk. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait) def sparsify( self, headers=None, query=None, wait=True, **kwargs ): """ Sparsify the disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To remove a disk use the <<services/disk/methods/remove, remove>> operation of the service that manages that disk. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'sparsify', None, headers, query, wait) def update( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Updates the disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To update a disk use the <<services/disk/methods/update, update>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: The update to apply to the disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(disk, headers, query, wait) def permissions_service(self): """ Reference to the service that manages the permissions assigned to the disk. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'AttachedStorageDomainDiskService:%s' % self._path
Manages a single disk available in a storage domain attached to a data center.
IMPORTANT: Since version 4.2 of the engine this service is intended only to list disks available in the storage
domain, and to register unregistered disks. All the other operations, like copying a disk, moving a disk, etc, have
been deprecated and will be removed in the future. To perform those operations use the <
View Source
def __init__(self, connection, path): super(AttachedStorageDomainDiskService, self).__init__(connection, path) self._permissions_service = None self._statistics_service = None
Creates a new service that will use the given connection and path.
View Source
def copy( self, disk=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Copies a disk to the specified storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To copy a disk use the <<services/disk/methods/copy, copy>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: Description of the resulting disk. `storage_domain`:: The storage domain where the new disk will be created. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( disk=disk, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait)
Copies a disk to the specified storage domain.
IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. To copy a disk use the <
This method supports the following parameters:
disk:: Description of the resulting disk.
storage_domain:: The storage domain where the new disk will be created.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def export( self, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a disk to an export storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To export a disk use the <<services/disk/methods/export, export>> operation of the service that manages that disk. This method supports the following parameters: `storage_domain`:: The export storage domain where the disk should be exported to. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('storage_domain', storage_domain, types.StorageDomain), ]) # Populate the action: action = types.Action( storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait)
Exports a disk to an export storage domain.
IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. To export a disk use the <
This method supports the following parameters:
storage_domain:: The export storage domain where the disk should be exported to.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the description of the disk.
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
move(
self,
async_=None,
filter=None,
storage_domain=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def move( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Moves a disk to another storage domain. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To move a disk use the <<services/disk/methods/move, move>> operation of the service that manages that disk. This method supports the following parameters: `storage_domain`:: The storage domain where the disk will be moved to. `async_`:: Indicates if the move should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait)
Moves a disk to another storage domain.
IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. To move a disk use the <
This method supports the following parameters:
storage_domain:: The storage domain where the disk will be moved to.
async_:: Indicates if the move should be performed asynchronously.
filter:: Indicates if the results should be filtered according to the permissions of the user.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def register( self, headers=None, query=None, wait=True, **kwargs ): """ Registers an unregistered disk. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'register', None, headers, query, wait)
Registers an unregistered disk.
View Source
def remove( self, headers=None, query=None, wait=True, **kwargs ): """ Removes a disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To remove a disk use the <<services/disk/methods/remove, remove>> operation of the service that manages that disk. """ # Check the types of the parameters: Service._check_types([ ]) # Build the URL: query = query or {} # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes a disk.
IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. To remove a disk use the <
View Source
def sparsify( self, headers=None, query=None, wait=True, **kwargs ): """ Sparsify the disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To remove a disk use the <<services/disk/methods/remove, remove>> operation of the service that manages that disk. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'sparsify', None, headers, query, wait)
Sparsify the disk.
IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. To remove a disk use the <
View Source
def update( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Updates the disk. IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards compatibility. It will be removed in the future. To update a disk use the <<services/disk/methods/update, update>> operation of the service that manages that disk. This method supports the following parameters: `disk`:: The update to apply to the disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(disk, headers, query, wait)
Updates the disk.
IMPORTANT: Since version 4.2 of the engine this operation is deprecated, and preserved only for backwards
compatibility. It will be removed in the future. To update a disk use the
<
This method supports the following parameters:
disk:: The update to apply to the disk.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def permissions_service(self): """ Reference to the service that manages the permissions assigned to the disk. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
Reference to the service that manages the permissions assigned to the disk.
View Source
def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class DiskService(MeasurableService): """ Manages a single disk. """ def __init__(self, connection, path): super(DiskService, self).__init__(connection, path) self._disk_snapshots_service = None self._permissions_service = None self._statistics_service = None def copy( self, async_=None, disk=None, disk_profile=None, filter=None, quota=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ This operation copies a disk to the specified storage domain. For example, a disk can be copied using the following request: [source] ---- POST /ovirt-engine/api/disks/123/copy ---- With a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> <disk> <name>mydisk</name> </disk> </action> ---- If the disk profile or the quota currently used by the disk are not defined for the new storage domain, they can be explicitly specified. If they are not specified, the first available disk profile and the default quota are used. For example, to specify disk profile `987` and quota `753`, send a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> <disk_profile id="987"/> <quota id="753"/> </action> ---- This method supports the following parameters: `storage_domain`:: The storage domain where the new disk is created. This can be specified using the `id` or `name` attributes. For example, to copy a disk to the storage domain called `mydata`, send a request like this: .... POST /ovirt-engine/api/storagedomains/123/disks/789 .... With a request body like this: [source,xml] ---- <action> <storage_domain> <name>mydata</name> </storage_domain> </action> ---- `disk_profile`:: Disk profile for the disk in the new storage domain. Disk profiles are defined for storage domains, so the old disk profile will not exist in the new storage domain. If this parameter is not used, the first disk profile from the new storage domain to which the user has permissions will be assigned to the disk. `quota`:: Quota for the disk in the new storage domain. This optional parameter can be used to specify new quota for the disk, because the current quota may not be defined for the new storage domain. If this parameter is not used and the old quota is not defined for the new storage domain, the default (unlimited) quota will be assigned to the disk. `async_`:: Indicates if the copy should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('disk', disk, types.Disk), ('disk_profile', disk_profile, types.DiskProfile), ('filter', filter, bool), ('quota', quota, types.Quota), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, disk=disk, disk_profile=disk_profile, filter=filter, quota=quota, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait) def export( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a disk to an export storage domain. This method supports the following parameters: `storage_domain`:: The export storage domain where the disk will be exported to. `async_`:: Indicates if the export should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait) def get( self, all_content=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `all_content`:: Indicates if all of the attributes of the disk should be included in the response. By default the following disk attributes are excluded: - `vms` For example, to retrieve the complete representation of disk '123': .... GET /ovirt-engine/api/disks/123?all_content=true .... `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def move( self, async_=None, disk_profile=None, filter=None, quota=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Moves a disk to another storage domain. For example, to move the disk with identifier `123` to a storage domain with identifier `456` send the following request: [source] ---- POST /ovirt-engine/api/disks/123/move ---- With the following request body: [source,xml] ---- <action> <storage_domain id="456"/> </action> ---- If the disk profile or the quota used currently by the disk aren't defined for the new storage domain, then they can be explicitly specified. If they aren't then the first available disk profile and the default quota are used. For example, to explicitly use disk profile `987` and quota `753` send a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> <disk_profile id="987"/> <quota id="753"/> </action> ---- This method supports the following parameters: `storage_domain`:: The storage domain where the disk will be moved to. `disk_profile`:: Disk profile for the disk in the new storage domain. Disk profiles are defined for storage domains, so the old disk profile will not exist in the new storage domain. If this parameter is not used, the first disk profile from the new storage domain to which the user has permissions will be assigned to the disk. `quota`:: Quota for the disk in the new storage domain. This optional parameter can be used to specify new quota for the disk, because the current quota may not be defined for the new storage domain. If this parameter is not used and the old quota is not defined for the new storage domain, the default (unlimited) quota will be assigned to the disk. `async_`:: Indicates if the move should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('disk_profile', disk_profile, types.DiskProfile), ('filter', filter, bool), ('quota', quota, types.Quota), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, disk_profile=disk_profile, filter=filter, quota=quota, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait) def reduce( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Reduces the size of the disk image. Invokes _reduce_ on the logical volume (i.e. this is only applicable for block storage domains). This is applicable for floating disks and disks attached to non-running virtual machines. There is no need to specify the size as the optimal size is calculated automatically. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reduce', None, headers, query, wait) def refresh_lun( self, host=None, headers=None, query=None, wait=True, **kwargs ): """ Refreshes a direct LUN disk with up-to-date information from the storage. Refreshing a direct LUN disk is useful when: - The LUN was added using the API without the host parameter, and therefore does not contain any information from the storage (see <<services/disks/methods/add, DisksService::add>>). - New information about the LUN is available on the storage and you want to update the LUN with it. To refresh direct LUN disk `123` using host `456`, send the following request: [source] ---- POST /ovirt-engine/api/disks/123/refreshlun ---- With the following request body: [source,xml] ---- <action> <host id='456'/> </action> ---- This method supports the following parameters: `host`:: The host that will be used to refresh the direct LUN disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ]) # Populate the action: action = types.Action( host=host, ) # Send the request and wait for the response: return self._internal_action(action, 'refreshlun', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a disk. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def sparsify( self, headers=None, query=None, wait=True, **kwargs ): """ Sparsify the disk. Sparsification frees space in the disk image that is not used by its filesystem. As a result, the image will occupy less space on the storage. Currently sparsification works only on disks without snapshots. Disks having derived disks are also not allowed. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'sparsify', None, headers, query, wait) def update( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Updates the parameters of the specified disk. This operation allows updating the following floating disk properties: * For Image disks: `provisioned_size`, `alias`, `description`, `wipe_after_delete`, `shareable`, `backup` and `disk_profile`. * For LUN disks: `alias`, `description` and `shareable`. * For Cinder and Managed Block disks: `provisioned_size`, `alias` and `description`. * For VM attached disks, the `qcow_version` can also be updated. For example, a disk's update can be done by using the following request: [source] ---- PUT /ovirt-engine/api/disks/123 ---- With a request body like this: [source,xml] ---- <disk> <qcow_version>qcow2_v3</qcow_version> <alias>new-alias</alias> <description>new-desc</description> </disk> ---- Since the backend operation is asynchronous, the disk element that is returned to the user might not be synced with the changed properties. This method supports the following parameters: `disk`:: The update to apply to the disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(disk, headers, query, wait) def disk_snapshots_service(self): """ Reference to the service that manages the DiskSnapshots. For example, to list all disk snapshots under the disks resource '123': .... GET /ovirt-engine/api/disks/123/disksnapshots .... For example, to retrieve a specific disk snapshot '789' under the disk resource '123': .... GET /ovirt-engine/api/disks/123/disksnapshots/789 .... """ return DiskSnapshotsService(self._connection, '%s/disksnapshots' % self._path) def permissions_service(self): """ Reference to the service that manages the permissions assigned to the disk. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disksnapshots': return self.disk_snapshots_service() if path.startswith('disksnapshots/'): return self.disk_snapshots_service().service(path[14:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'DiskService:%s' % self._path
Manages a single disk.
View Source
def __init__(self, connection, path): super(DiskService, self).__init__(connection, path) self._disk_snapshots_service = None self._permissions_service = None self._statistics_service = None
Creates a new service that will use the given connection and path.
#
def
copy(
self,
async_=None,
disk=None,
disk_profile=None,
filter=None,
quota=None,
storage_domain=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def copy( self, async_=None, disk=None, disk_profile=None, filter=None, quota=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ This operation copies a disk to the specified storage domain. For example, a disk can be copied using the following request: [source] ---- POST /ovirt-engine/api/disks/123/copy ---- With a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> <disk> <name>mydisk</name> </disk> </action> ---- If the disk profile or the quota currently used by the disk are not defined for the new storage domain, they can be explicitly specified. If they are not specified, the first available disk profile and the default quota are used. For example, to specify disk profile `987` and quota `753`, send a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> <disk_profile id="987"/> <quota id="753"/> </action> ---- This method supports the following parameters: `storage_domain`:: The storage domain where the new disk is created. This can be specified using the `id` or `name` attributes. For example, to copy a disk to the storage domain called `mydata`, send a request like this: .... POST /ovirt-engine/api/storagedomains/123/disks/789 .... With a request body like this: [source,xml] ---- <action> <storage_domain> <name>mydata</name> </storage_domain> </action> ---- `disk_profile`:: Disk profile for the disk in the new storage domain. Disk profiles are defined for storage domains, so the old disk profile will not exist in the new storage domain. If this parameter is not used, the first disk profile from the new storage domain to which the user has permissions will be assigned to the disk. `quota`:: Quota for the disk in the new storage domain. This optional parameter can be used to specify new quota for the disk, because the current quota may not be defined for the new storage domain. If this parameter is not used and the old quota is not defined for the new storage domain, the default (unlimited) quota will be assigned to the disk. `async_`:: Indicates if the copy should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('disk', disk, types.Disk), ('disk_profile', disk_profile, types.DiskProfile), ('filter', filter, bool), ('quota', quota, types.Quota), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, disk=disk, disk_profile=disk_profile, filter=filter, quota=quota, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'copy', None, headers, query, wait)
This operation copies a disk to the specified storage domain. For example, a disk can be copied using the following request:
[source]
POST /ovirt-engine/api/disks/123/copy
With a request body like this:
[source,xml]
If the disk profile or the quota currently used by the disk are not defined for the new storage domain, they
can be explicitly specified. If they are not specified, the first available disk profile and the default quota are used.
For example, to specify disk profile 987 and quota 753, send a request body like this:
[source,xml]
This method supports the following parameters:
storage_domain:: The storage domain where the new disk is created. This can be specified using the id or name
attributes. For example, to copy a disk to the storage domain called mydata, send a request like this:
....
POST /ovirt-engine/api/storagedomains/123/disks/789
....
With a request body like this:
[source,xml]
disk_profile:: Disk profile for the disk in the new storage domain.
Disk profiles are defined for storage domains,
so the old disk profile will not exist in the new storage domain.
If this parameter is not used, the first disk profile from the new storage domain
to which the user has permissions will be assigned to the disk.
quota:: Quota for the disk in the new storage domain.
This optional parameter can be used to specify new quota for the disk,
because the current quota may not be defined for the new storage domain.
If this parameter is not used and the old quota is not defined for the new storage domain,
the default (unlimited) quota will be assigned to the disk.
async_:: Indicates if the copy should be performed asynchronously.
filter:: Indicates if the results should be filtered according to the permissions of the user.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
export(
self,
async_=None,
filter=None,
storage_domain=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def export( self, async_=None, filter=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Exports a disk to an export storage domain. This method supports the following parameters: `storage_domain`:: The export storage domain where the disk will be exported to. `async_`:: Indicates if the export should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('filter', filter, bool), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, filter=filter, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'export', None, headers, query, wait)
Exports a disk to an export storage domain.
This method supports the following parameters:
storage_domain:: The export storage domain where the disk will be exported to.
async_:: Indicates if the export should be performed asynchronously.
filter:: Indicates if the results should be filtered according to the permissions of the user.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def get( self, all_content=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the description of the disk. This method supports the following parameters: `all_content`:: Indicates if all of the attributes of the disk should be included in the response. By default the following disk attributes are excluded: - `vms` For example, to retrieve the complete representation of disk '123': .... GET /ovirt-engine/api/disks/123?all_content=true .... `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the description of the disk.
This method supports the following parameters:
all_content:: Indicates if all of the attributes of the disk should be included in the response.
By default the following disk attributes are excluded:
vmsFor example, to retrieve the complete representation of disk '123': .... GET /ovirt-engine/api/disks/123?all_content=true ....
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
move(
self,
async_=None,
disk_profile=None,
filter=None,
quota=None,
storage_domain=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def move( self, async_=None, disk_profile=None, filter=None, quota=None, storage_domain=None, headers=None, query=None, wait=True, **kwargs ): """ Moves a disk to another storage domain. For example, to move the disk with identifier `123` to a storage domain with identifier `456` send the following request: [source] ---- POST /ovirt-engine/api/disks/123/move ---- With the following request body: [source,xml] ---- <action> <storage_domain id="456"/> </action> ---- If the disk profile or the quota used currently by the disk aren't defined for the new storage domain, then they can be explicitly specified. If they aren't then the first available disk profile and the default quota are used. For example, to explicitly use disk profile `987` and quota `753` send a request body like this: [source,xml] ---- <action> <storage_domain id="456"/> <disk_profile id="987"/> <quota id="753"/> </action> ---- This method supports the following parameters: `storage_domain`:: The storage domain where the disk will be moved to. `disk_profile`:: Disk profile for the disk in the new storage domain. Disk profiles are defined for storage domains, so the old disk profile will not exist in the new storage domain. If this parameter is not used, the first disk profile from the new storage domain to which the user has permissions will be assigned to the disk. `quota`:: Quota for the disk in the new storage domain. This optional parameter can be used to specify new quota for the disk, because the current quota may not be defined for the new storage domain. If this parameter is not used and the old quota is not defined for the new storage domain, the default (unlimited) quota will be assigned to the disk. `async_`:: Indicates if the move should be performed asynchronously. `filter`:: Indicates if the results should be filtered according to the permissions of the user. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('disk_profile', disk_profile, types.DiskProfile), ('filter', filter, bool), ('quota', quota, types.Quota), ('storage_domain', storage_domain, types.StorageDomain), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, disk_profile=disk_profile, filter=filter, quota=quota, storage_domain=storage_domain, ) # Send the request and wait for the response: return self._internal_action(action, 'move', None, headers, query, wait)
Moves a disk to another storage domain.
For example, to move the disk with identifier 123 to a storage domain with identifier 456 send the following
request:
[source]
POST /ovirt-engine/api/disks/123/move
With the following request body:
[source,xml]
If the disk profile or the quota used currently by
the disk aren't defined for the new storage domain,
then they can be explicitly specified. If they aren't
then the first available disk profile and the default
quota are used.
For example, to explicitly use disk profile 987 and
quota 753 send a request body like this:
[source,xml]
This method supports the following parameters:
storage_domain:: The storage domain where the disk will be moved to.
disk_profile:: Disk profile for the disk in the new storage domain.
Disk profiles are defined for storage domains,
so the old disk profile will not exist in the new storage domain.
If this parameter is not used, the first disk profile from the new storage domain
to which the user has permissions will be assigned to the disk.
quota:: Quota for the disk in the new storage domain.
This optional parameter can be used to specify new quota for the disk,
because the current quota may not be defined for the new storage domain.
If this parameter is not used and the old quota is not defined for the new storage domain,
the default (unlimited) quota will be assigned to the disk.
async_:: Indicates if the move should be performed asynchronously.
filter:: Indicates if the results should be filtered according to the permissions of the user.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def reduce( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Reduces the size of the disk image. Invokes _reduce_ on the logical volume (i.e. this is only applicable for block storage domains). This is applicable for floating disks and disks attached to non-running virtual machines. There is no need to specify the size as the optimal size is calculated automatically. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'reduce', None, headers, query, wait)
Reduces the size of the disk image. Invokes _reduce_ on the logical volume (i.e. this is only applicable for block storage domains). This is applicable for floating disks and disks attached to non-running virtual machines. There is no need to specify the size as the optimal size is calculated automatically.
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def refresh_lun( self, host=None, headers=None, query=None, wait=True, **kwargs ): """ Refreshes a direct LUN disk with up-to-date information from the storage. Refreshing a direct LUN disk is useful when: - The LUN was added using the API without the host parameter, and therefore does not contain any information from the storage (see <<services/disks/methods/add, DisksService::add>>). - New information about the LUN is available on the storage and you want to update the LUN with it. To refresh direct LUN disk `123` using host `456`, send the following request: [source] ---- POST /ovirt-engine/api/disks/123/refreshlun ---- With the following request body: [source,xml] ---- <action> <host id='456'/> </action> ---- This method supports the following parameters: `host`:: The host that will be used to refresh the direct LUN disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ]) # Populate the action: action = types.Action( host=host, ) # Send the request and wait for the response: return self._internal_action(action, 'refreshlun', None, headers, query, wait)
Refreshes a direct LUN disk with up-to-date information from the storage. Refreshing a direct LUN disk is useful when:
- The LUN was added using the API without the host parameter, and therefore does not contain
any information from the storage (see <
>). - New information about the LUN is available on the storage and you want to update the LUN with it.
To refresh direct LUN disk
123using host456, send the following request:
[source]
POST /ovirt-engine/api/disks/123/refreshlun
With the following request body:
[source,xml]
This method supports the following parameters:
host:: The host that will be used to refresh the direct LUN disk.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a disk. This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes a disk.
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def sparsify( self, headers=None, query=None, wait=True, **kwargs ): """ Sparsify the disk. Sparsification frees space in the disk image that is not used by its filesystem. As a result, the image will occupy less space on the storage. Currently sparsification works only on disks without snapshots. Disks having derived disks are also not allowed. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'sparsify', None, headers, query, wait)
Sparsify the disk. Sparsification frees space in the disk image that is not used by its filesystem. As a result, the image will occupy less space on the storage. Currently sparsification works only on disks without snapshots. Disks having derived disks are also not allowed.
View Source
def update( self, disk, headers=None, query=None, wait=True, **kwargs ): """ Updates the parameters of the specified disk. This operation allows updating the following floating disk properties: * For Image disks: `provisioned_size`, `alias`, `description`, `wipe_after_delete`, `shareable`, `backup` and `disk_profile`. * For LUN disks: `alias`, `description` and `shareable`. * For Cinder and Managed Block disks: `provisioned_size`, `alias` and `description`. * For VM attached disks, the `qcow_version` can also be updated. For example, a disk's update can be done by using the following request: [source] ---- PUT /ovirt-engine/api/disks/123 ---- With a request body like this: [source,xml] ---- <disk> <qcow_version>qcow2_v3</qcow_version> <alias>new-alias</alias> <description>new-desc</description> </disk> ---- Since the backend operation is asynchronous, the disk element that is returned to the user might not be synced with the changed properties. This method supports the following parameters: `disk`:: The update to apply to the disk. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('disk', disk, types.Disk), ]) # Build the URL: query = query or {} # Send the request and wait for the response: return self._internal_update(disk, headers, query, wait)
Updates the parameters of the specified disk. This operation allows updating the following floating disk properties:
- For Image disks:
provisioned_size,alias,description,wipe_after_delete,shareable,backupanddisk_profile. - For LUN disks:
alias,descriptionandshareable. - For Cinder and Managed Block disks:
provisioned_size,aliasanddescription. - For VM attached disks, the
qcow_versioncan also be updated. For example, a disk's update can be done by using the following request:
[source]
PUT /ovirt-engine/api/disks/123
With a request body like this:
[source,xml]
Since the backend operation is asynchronous, the disk element that is returned to the user might not be synced with the changed properties.
This method supports the following parameters:
disk:: The update to apply to the disk.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def disk_snapshots_service(self): """ Reference to the service that manages the DiskSnapshots. For example, to list all disk snapshots under the disks resource '123': .... GET /ovirt-engine/api/disks/123/disksnapshots .... For example, to retrieve a specific disk snapshot '789' under the disk resource '123': .... GET /ovirt-engine/api/disks/123/disksnapshots/789 .... """ return DiskSnapshotsService(self._connection, '%s/disksnapshots' % self._path)
Reference to the service that manages the DiskSnapshots. For example, to list all disk snapshots under the disks resource '123': .... GET /ovirt-engine/api/disks/123/disksnapshots .... For example, to retrieve a specific disk snapshot '789' under the disk resource '123': .... GET /ovirt-engine/api/disks/123/disksnapshots/789 ....
View Source
def permissions_service(self): """ Reference to the service that manages the permissions assigned to the disk. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
Reference to the service that manages the permissions assigned to the disk.
View Source
def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'disksnapshots': return self.disk_snapshots_service() if path.startswith('disksnapshots/'): return self.disk_snapshots_service().service(path[14:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class EngineKatelloErrataService(KatelloErrataService): """ A service to manage Katello errata assigned to the engine. The information is retrieved from Katello. """ def __init__(self, connection, path): super(EngineKatelloErrataService, self).__init__(connection, path) self._katello_erratum_service = None def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representation of the Katello errata. [source] ---- GET /ovirt-engine/api/katelloerrata ---- You will receive response in XML like this one: [source,xml] ---- <katello_errata> <katello_erratum href="/ovirt-engine/api/katelloerrata/123" id="123"> <name>RHBA-2013:XYZ</name> <description>The description of the erratum</description> <title>some bug fix update</title> <type>bugfix</type> <issued>2013-11-20T02:00:00.000+02:00</issued> <solution>Few guidelines regarding the solution</solution> <summary>Updated packages that fix one bug are now available for XYZ</summary> <packages> <package> <name>libipa_hbac-1.9.2-82.11.el6_4.i686</name> </package> ... </packages> </katello_erratum> ... </katello_errata> ---- The order of the returned list of erratum isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of errata to return. If not specified all the errata are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait) def katello_erratum_service(self, id): """ Reference to the Katello erratum service. Use this service to view the erratum by its id. """ Service._check_types([ ('id', id, str), ]) return KatelloErratumService(self._connection, '%s/%s' % (self._path, id)) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.katello_erratum_service(path) return self.katello_erratum_service(path[:index]).service(path[index + 1:]) def __str__(self): return 'EngineKatelloErrataService:%s' % self._path
A service to manage Katello errata assigned to the engine. The information is retrieved from Katello.
View Source
def __init__(self, connection, path): super(EngineKatelloErrataService, self).__init__(connection, path) self._katello_erratum_service = None
Creates a new service that will use the given connection and path.
View Source
def list( self, follow=None, max=None, headers=None, query=None, wait=True, **kwargs ): """ Retrieves the representation of the Katello errata. [source] ---- GET /ovirt-engine/api/katelloerrata ---- You will receive response in XML like this one: [source,xml] ---- <katello_errata> <katello_erratum href="/ovirt-engine/api/katelloerrata/123" id="123"> <name>RHBA-2013:XYZ</name> <description>The description of the erratum</description> <title>some bug fix update</title> <type>bugfix</type> <issued>2013-11-20T02:00:00.000+02:00</issued> <solution>Few guidelines regarding the solution</solution> <summary>Updated packages that fix one bug are now available for XYZ</summary> <packages> <package> <name>libipa_hbac-1.9.2-82.11.el6_4.i686</name> </package> ... </packages> </katello_erratum> ... </katello_errata> ---- The order of the returned list of erratum isn't guaranteed. This method supports the following parameters: `max`:: Sets the maximum number of errata to return. If not specified all the errata are returned. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ('max', max, int), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow if max is not None: max = Writer.render_integer(max) query['max'] = max # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Retrieves the representation of the Katello errata.
[source]
GET /ovirt-engine/api/katelloerrata
You will receive response in XML like this one:
[source,xml]
The order of the returned list of erratum isn't guaranteed.
This method supports the following parameters:
max:: Sets the maximum number of errata to return. If not specified all the errata are returned.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def katello_erratum_service(self, id): """ Reference to the Katello erratum service. Use this service to view the erratum by its id. """ Service._check_types([ ('id', id, str), ]) return KatelloErratumService(self._connection, '%s/%s' % (self._path, id))
Reference to the Katello erratum service. Use this service to view the erratum by its id.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self index = path.find('/') if index == -1: return self.katello_erratum_service(path) return self.katello_erratum_service(path[:index]).service(path[index + 1:])
Service locator method, returns individual service on which the URI is dispatched.
View Source
class ExternalHostProviderService(ExternalProviderService): """ Represents an external host provider, such as Foreman or Satellite. See https://www.theforeman.org/ for more details on Foreman. See https://access.redhat.com/products/red-hat-satellite for more details on Red Hat Satellite. """ def __init__(self, connection, path): super(ExternalHostProviderService, self).__init__(connection, path) self._certificates_service = None self._compute_resources_service = None self._discovered_hosts_service = None self._host_groups_service = None self._hosts_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get external host provider information Host provider, Foreman or Satellite, can be set as an external provider in ovirt. To see details about specific host providers attached to ovirt use this API. For example, to get the details of host provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123 .... The response will be like this: [source,xml] ---- <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"> <name>mysatellite</name> <requires_authentication>true</requires_authentication> <url>https://mysatellite.example.com</url> <username>admin</username> </external_host_provider> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait) def update( self, provider, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified external host provider in the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.ExternalHostProvider), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(provider, headers, query, wait) def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path) def compute_resources_service(self): """ """ return ExternalComputeResourcesService(self._connection, '%s/computeresources' % self._path) def discovered_hosts_service(self): """ """ return ExternalDiscoveredHostsService(self._connection, '%s/discoveredhosts' % self._path) def host_groups_service(self): """ """ return ExternalHostGroupsService(self._connection, '%s/hostgroups' % self._path) def hosts_service(self): """ """ return ExternalHostsService(self._connection, '%s/hosts' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) if path == 'computeresources': return self.compute_resources_service() if path.startswith('computeresources/'): return self.compute_resources_service().service(path[17:]) if path == 'discoveredhosts': return self.discovered_hosts_service() if path.startswith('discoveredhosts/'): return self.discovered_hosts_service().service(path[16:]) if path == 'hostgroups': return self.host_groups_service() if path.startswith('hostgroups/'): return self.host_groups_service().service(path[11:]) if path == 'hosts': return self.hosts_service() if path.startswith('hosts/'): return self.hosts_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'ExternalHostProviderService:%s' % self._path
Represents an external host provider, such as Foreman or Satellite. See https://www.theforeman.org/ for more details on Foreman. See https://access.redhat.com/products/red-hat-satellite for more details on Red Hat Satellite.
View Source
def __init__(self, connection, path): super(ExternalHostProviderService, self).__init__(connection, path) self._certificates_service = None self._compute_resources_service = None self._discovered_hosts_service = None self._host_groups_service = None self._hosts_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get external host provider information Host provider, Foreman or Satellite, can be set as an external provider in ovirt. To see details about specific host providers attached to ovirt use this API. For example, to get the details of host provider `123`, send a request like this: .... GET /ovirt-engine/api/externalhostproviders/123 .... The response will be like this: [source,xml] ---- <external_host_provider href="/ovirt-engine/api/externalhostproviders/123" id="123"> <name>mysatellite</name> <requires_authentication>true</requires_authentication> <url>https://mysatellite.example.com</url> <username>admin</username> </external_host_provider> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get external host provider information
Host provider, Foreman or Satellite, can be set as an external provider in ovirt. To see details about specific
host providers attached to ovirt use this API.
For example, to get the details of host provider 123, send a request like this:
....
GET /ovirt-engine/api/externalhostproviders/123
....
The response will be like this:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
import_certificates(
self,
certificates=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def import_certificates( self, certificates=None, headers=None, query=None, wait=True, **kwargs ): """ Import the SSL certificates of the external host provider. """ # Check the types of the parameters: Service._check_types([ ('certificates', certificates, list), ]) # Populate the action: action = types.Action( certificates=certificates, ) # Send the request and wait for the response: return self._internal_action(action, 'importcertificates', None, headers, query, wait)
Import the SSL certificates of the external host provider.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def test_connectivity( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ In order to test connectivity for external provider we need to run following request where 123 is an id of a provider. [source] ---- POST /ovirt-engine/api/externalhostproviders/123/testconnectivity ---- This method supports the following parameters: `async_`:: Indicates if the test should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'testconnectivity', None, headers, query, wait)
In order to test connectivity for external provider we need to run following request where 123 is an id of a provider.
[source]
POST /ovirt-engine/api/externalhostproviders/123/testconnectivity
This method supports the following parameters:
async_:: Indicates if the test should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, provider, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified external host provider in the system. """ # Check the types of the parameters: Service._check_types([ ('provider', provider, types.ExternalHostProvider), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(provider, headers, query, wait)
Update the specified external host provider in the system.
View Source
def certificates_service(self): """ A service to view certificates for this external provider. """ return ExternalProviderCertificatesService(self._connection, '%s/certificates' % self._path)
A service to view certificates for this external provider.
View Source
def compute_resources_service(self): """ """ return ExternalComputeResourcesService(self._connection, '%s/computeresources' % self._path)
View Source
def discovered_hosts_service(self): """ """ return ExternalDiscoveredHostsService(self._connection, '%s/discoveredhosts' % self._path)
View Source
def host_groups_service(self): """ """ return ExternalHostGroupsService(self._connection, '%s/hostgroups' % self._path)
View Source
def hosts_service(self): """ """ return ExternalHostsService(self._connection, '%s/hosts' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'certificates': return self.certificates_service() if path.startswith('certificates/'): return self.certificates_service().service(path[13:]) if path == 'computeresources': return self.compute_resources_service() if path.startswith('computeresources/'): return self.compute_resources_service().service(path[17:]) if path == 'discoveredhosts': return self.discovered_hosts_service() if path.startswith('discoveredhosts/'): return self.discovered_hosts_service().service(path[16:]) if path == 'hostgroups': return self.host_groups_service() if path.startswith('hostgroups/'): return self.host_groups_service().service(path[11:]) if path == 'hosts': return self.hosts_service() if path.startswith('hosts/'): return self.hosts_service().service(path[6:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class GlusterBrickService(MeasurableService): """ This service manages a single gluster brick. """ def __init__(self, connection, path): super(GlusterBrickService, self).__init__(connection, path) self._statistics_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get details of a brick. Retrieves status details of brick from underlying gluster volume with header `All-Content` set to `true`. This is the equivalent of running `gluster volume status <volumename> <brickname> detail`. For example, to get the details of brick `234` of gluster volume `123`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/234 ---- Which will return a response body like this: [source,xml] ---- <brick id="234"> <name>host1:/rhgs/data/brick1</name> <brick_dir>/rhgs/data/brick1</brick_dir> <server_id>111</server_id> <status>up</status> <device>/dev/mapper/RHGS_vg1-lv_vmaddldisks</device> <fs_name>xfs</fs_name> <gluster_clients> <gluster_client> <bytes_read>2818417648</bytes_read> <bytes_written>1384694844</bytes_written> <client_port>1011</client_port> <host_name>client2</host_name> </gluster_client> </gluster_clients> <memory_pools> <memory_pool> <name>data-server:fd_t</name> <alloc_count>1626348</alloc_count> <cold_count>1020</cold_count> <hot_count>4</hot_count> <max_alloc>23</max_alloc> <max_stdalloc>0</max_stdalloc> <padded_size>140</padded_size> <pool_misses>0</pool_misses> </memory_pool> </memory_pools> <mnt_options>rw,seclabel,noatime,nodiratime,attr2,inode64,sunit=512,swidth=2048,noquota</mnt_options> <pid>25589</pid> <port>49155</port> </brick> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a brick. Removes a brick from the underlying gluster volume and deletes entries from database. This can be used only when removing a single brick without data migration. To remove multiple bricks and with data migration, use <<services/gluster_bricks/methods/migrate, migrate>> instead. For example, to delete brick `234` from gluster volume `123`, send a request like this: [source] ---- DELETE /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/234 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def replace( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Replaces this brick with a new one. IMPORTANT: This operation has been deprecated since version 3.5 of the engine and will be removed in the future. Use <<services/gluster_bricks/methods/add, add brick(s)>> and <<services/gluster_bricks/methods/migrate, migrate brick(s)>> instead. This method supports the following parameters: `async_`:: Indicates if the replacement should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'replace', None, headers, query, wait) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'GlusterBrickService:%s' % self._path
This service manages a single gluster brick.
View Source
def __init__(self, connection, path): super(GlusterBrickService, self).__init__(connection, path) self._statistics_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get details of a brick. Retrieves status details of brick from underlying gluster volume with header `All-Content` set to `true`. This is the equivalent of running `gluster volume status <volumename> <brickname> detail`. For example, to get the details of brick `234` of gluster volume `123`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/234 ---- Which will return a response body like this: [source,xml] ---- <brick id="234"> <name>host1:/rhgs/data/brick1</name> <brick_dir>/rhgs/data/brick1</brick_dir> <server_id>111</server_id> <status>up</status> <device>/dev/mapper/RHGS_vg1-lv_vmaddldisks</device> <fs_name>xfs</fs_name> <gluster_clients> <gluster_client> <bytes_read>2818417648</bytes_read> <bytes_written>1384694844</bytes_written> <client_port>1011</client_port> <host_name>client2</host_name> </gluster_client> </gluster_clients> <memory_pools> <memory_pool> <name>data-server:fd_t</name> <alloc_count>1626348</alloc_count> <cold_count>1020</cold_count> <hot_count>4</hot_count> <max_alloc>23</max_alloc> <max_stdalloc>0</max_stdalloc> <padded_size>140</padded_size> <pool_misses>0</pool_misses> </memory_pool> </memory_pools> <mnt_options>rw,seclabel,noatime,nodiratime,attr2,inode64,sunit=512,swidth=2048,noquota</mnt_options> <pid>25589</pid> <port>49155</port> </brick> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get details of a brick.
Retrieves status details of brick from underlying gluster volume with header All-Content set to true. This is
the equivalent of running gluster volume status <volumename> <brickname> detail.
For example, to get the details of brick 234 of gluster volume 123, send a request like this:
[source]
GET /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/234
Which will return a response body like this:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes a brick. Removes a brick from the underlying gluster volume and deletes entries from database. This can be used only when removing a single brick without data migration. To remove multiple bricks and with data migration, use <<services/gluster_bricks/methods/migrate, migrate>> instead. For example, to delete brick `234` from gluster volume `123`, send a request like this: [source] ---- DELETE /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/234 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes a brick.
Removes a brick from the underlying gluster volume and deletes entries from database. This can be used only when
removing a single brick without data migration. To remove multiple bricks and with data migration, use
<234 from gluster volume 123, send a request like this:
[source]
DELETE /ovirt-engine/api/clusters/567/glustervolumes/123/glusterbricks/234
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def replace( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Replaces this brick with a new one. IMPORTANT: This operation has been deprecated since version 3.5 of the engine and will be removed in the future. Use <<services/gluster_bricks/methods/add, add brick(s)>> and <<services/gluster_bricks/methods/migrate, migrate brick(s)>> instead. This method supports the following parameters: `async_`:: Indicates if the replacement should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'replace', None, headers, query, wait)
Replaces this brick with a new one.
IMPORTANT: This operation has been deprecated since version 3.5 of the engine and will be removed in the future.
Use < This method supports the following parameters:async_:: Indicates if the replacement should be performed asynchronously.headers:: Additional HTTP headers.query:: Additional URL query parameters.wait:: If True wait for the response.
View Source
def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class GlusterVolumeService(MeasurableService): """ This service manages a single gluster volume. """ def __init__(self, connection, path): super(GlusterVolumeService, self).__init__(connection, path) self._gluster_bricks_service = None self._statistics_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get the gluster volume details. For example, to get details of a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/456/glustervolumes/123 ---- This GET request will return the following output: [source,xml] ---- <gluster_volume id="123"> <name>data</name> <link href="/ovirt-engine/api/clusters/456/glustervolumes/123/glusterbricks" rel="glusterbricks"/> <disperse_count>0</disperse_count> <options> <option> <name>storage.owner-gid</name> <value>36</value> </option> <option> <name>performance.io-cache</name> <value>off</value> </option> <option> <name>cluster.data-self-heal-algorithm</name> <value>full</value> </option> </options> <redundancy_count>0</redundancy_count> <replica_count>3</replica_count> <status>up</status> <stripe_count>0</stripe_count> <transport_types> <transport_type>tcp</transport_type> </transport_types> <volume_type>replicate</volume_type> </gluster_volume> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def get_profile_statistics( self, headers=None, query=None, wait=True, **kwargs ): """ Get gluster volume profile statistics. For example, to get profile statistics for a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/getprofilestatistics ---- """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'getprofilestatistics', 'details', headers, query, wait) def rebalance( self, async_=None, fix_layout=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Rebalance the gluster volume. Rebalancing a gluster volume helps to distribute the data evenly across all the bricks. After expanding or shrinking a gluster volume (without migrating data), we need to rebalance the data among the bricks. In a non-replicated volume, all bricks should be online to perform the rebalance operation. In a replicated volume, at least one of the bricks in the replica should be online. For example, to rebalance a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/rebalance ---- This method supports the following parameters: `fix_layout`:: If set to true, rebalance will only fix the layout so that new data added to the volume is distributed across all the hosts. But it will not migrate/rebalance the existing data. Default is `false`. `force`:: Indicates if the rebalance should be force started. The rebalance command can be executed with the force option even when the older clients are connected to the cluster. However, this could lead to a data loss situation. Default is `false`. `async_`:: Indicates if the rebalance should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('fix_layout', fix_layout, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, fix_layout=fix_layout, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'rebalance', None, headers, query, wait) def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the gluster volume. For example, to remove a volume with identifier `123` in cluster `456`, send a request like this: [source] ---- DELETE /ovirt-engine/api/clusters/456/glustervolumes/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def reset_all_options( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Resets all the options set in the gluster volume. For example, to reset all options in a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/resetalloptions ---- This method supports the following parameters: `async_`:: Indicates if the reset should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'resetalloptions', None, headers, query, wait) def reset_option( self, async_=None, force=None, option=None, headers=None, query=None, wait=True, **kwargs ): """ Resets a particular option in the gluster volume. For example, to reset a particular option `option1` in a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/resetoption ---- With the following request body: [source,xml] ---- <action> <option name="option1"/> </action> ---- This method supports the following parameters: `option`:: Option to reset. `async_`:: Indicates if the reset should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('option', option, types.Option), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, option=option, ) # Send the request and wait for the response: return self._internal_action(action, 'resetoption', None, headers, query, wait) def set_option( self, async_=None, option=None, headers=None, query=None, wait=True, **kwargs ): """ Sets a particular option in the gluster volume. For example, to set `option1` with value `value1` in a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/setoption ---- With the following request body: [source,xml] ---- <action> <option name="option1" value="value1"/> </action> ---- This method supports the following parameters: `option`:: Option to set. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('option', option, types.Option), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, option=option, ) # Send the request and wait for the response: return self._internal_action(action, 'setoption', None, headers, query, wait) def start( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Starts the gluster volume. A Gluster Volume should be started to read/write data. For example, to start a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/start ---- This method supports the following parameters: `force`:: Indicates if the volume should be force started. If a gluster volume is started already but few/all bricks are down then force start can be used to bring all the bricks up. Default is `false`. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'start', None, headers, query, wait) def start_profile( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Start profiling the gluster volume. For example, to start profiling a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/startprofile ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'startprofile', None, headers, query, wait) def stop( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Stops the gluster volume. Stopping a volume will make its data inaccessible. For example, to stop a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/stop ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'stop', None, headers, query, wait) def stop_profile( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Stop profiling the gluster volume. For example, to stop profiling a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/stopprofile ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'stopprofile', None, headers, query, wait) def stop_rebalance( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Stop rebalancing the gluster volume. For example, to stop rebalancing a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/stoprebalance ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'stoprebalance', None, headers, query, wait) def gluster_bricks_service(self): """ Reference to a service managing gluster bricks. """ return GlusterBricksService(self._connection, '%s/glusterbricks' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'glusterbricks': return self.gluster_bricks_service() if path.startswith('glusterbricks/'): return self.gluster_bricks_service().service(path[14:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'GlusterVolumeService:%s' % self._path
This service manages a single gluster volume.
View Source
def __init__(self, connection, path): super(GlusterVolumeService, self).__init__(connection, path) self._gluster_bricks_service = None self._statistics_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Get the gluster volume details. For example, to get details of a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- GET /ovirt-engine/api/clusters/456/glustervolumes/123 ---- This GET request will return the following output: [source,xml] ---- <gluster_volume id="123"> <name>data</name> <link href="/ovirt-engine/api/clusters/456/glustervolumes/123/glusterbricks" rel="glusterbricks"/> <disperse_count>0</disperse_count> <options> <option> <name>storage.owner-gid</name> <value>36</value> </option> <option> <name>performance.io-cache</name> <value>off</value> </option> <option> <name>cluster.data-self-heal-algorithm</name> <value>full</value> </option> </options> <redundancy_count>0</redundancy_count> <replica_count>3</replica_count> <status>up</status> <stripe_count>0</stripe_count> <transport_types> <transport_type>tcp</transport_type> </transport_types> <volume_type>replicate</volume_type> </gluster_volume> ---- This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Get the gluster volume details.
For example, to get details of a gluster volume with identifier 123 in cluster 456, send a request like this:
[source]
GET /ovirt-engine/api/clusters/456/glustervolumes/123
This GET request will return the following output:
[source,xml]
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def get_profile_statistics( self, headers=None, query=None, wait=True, **kwargs ): """ Get gluster volume profile statistics. For example, to get profile statistics for a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/getprofilestatistics ---- """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'getprofilestatistics', 'details', headers, query, wait)
Get gluster volume profile statistics.
For example, to get profile statistics for a gluster volume with identifier 123 in cluster 456, send a
request like this:
[source]
POST /ovirt-engine/api/clusters/456/glustervolumes/123/getprofilestatistics
#
def
rebalance(
self,
async_=None,
fix_layout=None,
force=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def rebalance( self, async_=None, fix_layout=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Rebalance the gluster volume. Rebalancing a gluster volume helps to distribute the data evenly across all the bricks. After expanding or shrinking a gluster volume (without migrating data), we need to rebalance the data among the bricks. In a non-replicated volume, all bricks should be online to perform the rebalance operation. In a replicated volume, at least one of the bricks in the replica should be online. For example, to rebalance a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/rebalance ---- This method supports the following parameters: `fix_layout`:: If set to true, rebalance will only fix the layout so that new data added to the volume is distributed across all the hosts. But it will not migrate/rebalance the existing data. Default is `false`. `force`:: Indicates if the rebalance should be force started. The rebalance command can be executed with the force option even when the older clients are connected to the cluster. However, this could lead to a data loss situation. Default is `false`. `async_`:: Indicates if the rebalance should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('fix_layout', fix_layout, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, fix_layout=fix_layout, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'rebalance', None, headers, query, wait)
Rebalance the gluster volume.
Rebalancing a gluster volume helps to distribute the data evenly across all the bricks. After expanding or
shrinking a gluster volume (without migrating data), we need to rebalance the data among the bricks. In a
non-replicated volume, all bricks should be online to perform the rebalance operation. In a replicated volume, at
least one of the bricks in the replica should be online.
For example, to rebalance a gluster volume with identifier 123 in cluster 456, send a request like this:
[source]
POST /ovirt-engine/api/clusters/456/glustervolumes/123/rebalance
This method supports the following parameters:
fix_layout:: If set to true, rebalance will only fix the layout so that new data added to the volume is distributed
across all the hosts. But it will not migrate/rebalance the existing data. Default is false.
force:: Indicates if the rebalance should be force started. The rebalance command can be executed with the force
option even when the older clients are connected to the cluster. However, this could lead to a data loss
situation. Default is false.
async_:: Indicates if the rebalance should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Removes the gluster volume. For example, to remove a volume with identifier `123` in cluster `456`, send a request like this: [source] ---- DELETE /ovirt-engine/api/clusters/456/glustervolumes/123 ---- This method supports the following parameters: `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Removes the gluster volume.
For example, to remove a volume with identifier 123 in cluster 456, send a request like this:
[source]
DELETE /ovirt-engine/api/clusters/456/glustervolumes/123
This method supports the following parameters:
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def reset_all_options( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Resets all the options set in the gluster volume. For example, to reset all options in a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/resetalloptions ---- This method supports the following parameters: `async_`:: Indicates if the reset should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'resetalloptions', None, headers, query, wait)
Resets all the options set in the gluster volume.
For example, to reset all options in a gluster volume with identifier 123 in cluster 456, send a request like
this:
[source]
POST /ovirt-engine/api/clusters/456/glustervolumes/123/resetalloptions
This method supports the following parameters:
async_:: Indicates if the reset should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
reset_option(
self,
async_=None,
force=None,
option=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def reset_option( self, async_=None, force=None, option=None, headers=None, query=None, wait=True, **kwargs ): """ Resets a particular option in the gluster volume. For example, to reset a particular option `option1` in a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/resetoption ---- With the following request body: [source,xml] ---- <action> <option name="option1"/> </action> ---- This method supports the following parameters: `option`:: Option to reset. `async_`:: Indicates if the reset should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ('option', option, types.Option), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, option=option, ) # Send the request and wait for the response: return self._internal_action(action, 'resetoption', None, headers, query, wait)
Resets a particular option in the gluster volume.
For example, to reset a particular option option1 in a gluster volume with identifier 123 in cluster 456,
send a request like this:
[source]
POST /ovirt-engine/api/clusters/456/glustervolumes/123/resetoption
With the following request body:
[source,xml]
This method supports the following parameters:
option:: Option to reset.
async_:: Indicates if the reset should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def set_option( self, async_=None, option=None, headers=None, query=None, wait=True, **kwargs ): """ Sets a particular option in the gluster volume. For example, to set `option1` with value `value1` in a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/setoption ---- With the following request body: [source,xml] ---- <action> <option name="option1" value="value1"/> </action> ---- This method supports the following parameters: `option`:: Option to set. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('option', option, types.Option), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, option=option, ) # Send the request and wait for the response: return self._internal_action(action, 'setoption', None, headers, query, wait)
Sets a particular option in the gluster volume.
For example, to set option1 with value value1 in a gluster volume with identifier 123 in cluster 456,
send a request like this:
[source]
POST /ovirt-engine/api/clusters/456/glustervolumes/123/setoption
With the following request body:
[source,xml]
This method supports the following parameters:
option:: Option to set.
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def start( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Starts the gluster volume. A Gluster Volume should be started to read/write data. For example, to start a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/start ---- This method supports the following parameters: `force`:: Indicates if the volume should be force started. If a gluster volume is started already but few/all bricks are down then force start can be used to bring all the bricks up. Default is `false`. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'start', None, headers, query, wait)
Starts the gluster volume.
A Gluster Volume should be started to read/write data. For example, to start a gluster volume with identifier
123 in cluster 456, send a request like this:
[source]
POST /ovirt-engine/api/clusters/456/glustervolumes/123/start
This method supports the following parameters:
force:: Indicates if the volume should be force started. If a gluster volume is started already but few/all bricks
are down then force start can be used to bring all the bricks up. Default is false.
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def start_profile( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Start profiling the gluster volume. For example, to start profiling a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/startprofile ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'startprofile', None, headers, query, wait)
Start profiling the gluster volume.
For example, to start profiling a gluster volume with identifier 123 in cluster 456, send a request like this:
[source]
POST /ovirt-engine/api/clusters/456/glustervolumes/123/startprofile
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def stop( self, async_=None, force=None, headers=None, query=None, wait=True, **kwargs ): """ Stops the gluster volume. Stopping a volume will make its data inaccessible. For example, to stop a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/stop ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('force', force, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, force=force, ) # Send the request and wait for the response: return self._internal_action(action, 'stop', None, headers, query, wait)
Stops the gluster volume.
Stopping a volume will make its data inaccessible.
For example, to stop a gluster volume with identifier 123 in cluster 456, send a request like this:
[source]
POST /ovirt-engine/api/clusters/456/glustervolumes/123/stop
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def stop_profile( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Stop profiling the gluster volume. For example, to stop profiling a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/stopprofile ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'stopprofile', None, headers, query, wait)
Stop profiling the gluster volume.
For example, to stop profiling a gluster volume with identifier 123 in cluster 456, send a request like this:
[source]
POST /ovirt-engine/api/clusters/456/glustervolumes/123/stopprofile
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def stop_rebalance( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Stop rebalancing the gluster volume. For example, to stop rebalancing a gluster volume with identifier `123` in cluster `456`, send a request like this: [source] ---- POST /ovirt-engine/api/clusters/456/glustervolumes/123/stoprebalance ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'stoprebalance', None, headers, query, wait)
Stop rebalancing the gluster volume.
For example, to stop rebalancing a gluster volume with identifier 123 in cluster 456, send a request like
this:
[source]
POST /ovirt-engine/api/clusters/456/glustervolumes/123/stoprebalance
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def gluster_bricks_service(self): """ Reference to a service managing gluster bricks. """ return GlusterBricksService(self._connection, '%s/glusterbricks' % self._path)
Reference to a service managing gluster bricks.
View Source
def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'glusterbricks': return self.gluster_bricks_service() if path.startswith('glusterbricks/'): return self.gluster_bricks_service().service(path[14:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class HostService(MeasurableService): """ A service to manage a host. """ def __init__(self, connection, path): super(HostService, self).__init__(connection, path) self._affinity_labels_service = None self._devices_service = None self._external_network_provider_configurations_service = None self._fence_agents_service = None self._hooks_service = None self._katello_errata_service = None self._network_attachments_service = None self._nics_service = None self._numa_nodes_service = None self._permissions_service = None self._statistics_service = None self._storage_service = None self._storage_connection_extensions_service = None self._tags_service = None self._unmanaged_networks_service = None def activate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Activates the host for use, for example to run virtual machines. This method supports the following parameters: `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait) def approve( self, activate=None, async_=None, cluster=None, host=None, reboot=None, headers=None, query=None, wait=True, **kwargs ): """ 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. This method supports the following parameters: `host`:: The host to approve. `cluster`:: The cluster where the host will be added after it is approved. `async_`:: Indicates if the approval should be performed asynchronously. `activate`:: When set to 'true', this host will be activated after its approval completes. When set to 'false' the host will remain in 'maintenance' status after its approval. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after approval. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('host', host, types.Host), ('reboot', reboot, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, cluster=cluster, host=host, reboot=reboot, ) # Send the request and wait for the response: return self._internal_action(action, 'approve', None, headers, query, wait) def commit_net_config( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ 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: [source] ---- POST /ovirt-engine/api/hosts/123/commitnetconfig ---- With a request body like this: [source,xml] ---- <action/> ---- IMPORTANT: Since {engine-name} 4.3, it is possible to also specify `commit_on_success` in the <<services/host/methods/setup_networks, setupnetworks>> request, in which case the new configuration is automatically saved in the {hypervisor-name} upon completing the setup and re-establishing connectivity between the {hypervisor-name} and {engine-name}, and without waiting for a separate <<services/host/methods/commit_net_config, commitnetconfig>> request. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'commitnetconfig', None, headers, query, wait) def copy_host_networks( self, async_=None, source_host=None, headers=None, query=None, wait=True, **kwargs ): """ Copy the network configuration of the specified host to current host. IMPORTANT: Any network attachments that are not present on the source host will be erased from the target host by the copy operation. To copy networks from another host, send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/copyhostnetworks ---- With a request body like this: [source,xml] ---- <action> <source_host id="456"/> </action> ---- This method supports the following parameters: `source_host`:: The host to copy networks from. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('source_host', source_host, types.Host), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, source_host=source_host, ) # Send the request and wait for the response: return self._internal_action(action, 'copyhostnetworks', None, headers, query, wait) def deactivate( self, async_=None, reason=None, stop_gluster_service=None, headers=None, query=None, wait=True, **kwargs ): """ Deactivates the host to perform maintenance tasks. This method supports the following parameters: `async_`:: Indicates if the deactivation should be performed asynchronously. `stop_gluster_service`:: 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`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('reason', reason, str), ('stop_gluster_service', stop_gluster_service, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, reason=reason, stop_gluster_service=stop_gluster_service, ) # Send the request and wait for the response: return self._internal_action(action, 'deactivate', None, headers, query, wait) def discover_iscsi( self, async_=None, iscsi=None, headers=None, query=None, wait=True, **kwargs ): """ Discovers iSCSI targets on the host, using the initiator details. Returns a list of IscsiDetails objects containing the discovered data. For example, to discover iSCSI targets available in `myiscsi.example.com`, from host `123`, send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/discoveriscsi ---- With a request body like this: [source,xml] ---- <action> <iscsi> <address>myiscsi.example.com</address> </iscsi> </action> ---- The result will be like this: [source,xml] ---- <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> ---- IMPORTANT: When using this method to discover iscsi targets, you can use an FQDN or an IP address, but you must use the iscsi details from the discovered targets results to log in using the iscsilogin method. This method supports the following parameters: `iscsi`:: The target iSCSI device. `async_`:: Indicates if the discovery should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('iscsi', iscsi, types.IscsiDetails), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, iscsi=iscsi, ) # Send the request and wait for the response: return self._internal_action(action, 'discoveriscsi', 'discovered_targets', headers, query, wait) def enroll_certificate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Enrolls the certificate of the host. Useful in case you get a warning that it is about to expire or has already expired. This method supports the following parameters: `async_`:: Indicates if the enrollment should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'enrollcertificate', None, headers, query, wait) def fence( self, async_=None, fence_type=None, maintenance_after_restart=None, headers=None, query=None, wait=True, **kwargs ): """ Controls the host's power management device. For example, to start the host. This can be done via: [source] ---- #!/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" ---- This method supports the following parameters: `async_`:: Indicates if the fencing should be performed asynchronously. `maintenance_after_restart`:: Indicates if host should be put into maintenance after restart. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('fence_type', fence_type, str), ('maintenance_after_restart', maintenance_after_restart, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, fence_type=fence_type, maintenance_after_restart=maintenance_after_restart, ) # Send the request and wait for the response: return self._internal_action(action, 'fence', 'power_management', headers, query, wait) def force_select_spm( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ To manually set a host as the storage pool manager (SPM). [source] ---- POST /ovirt-engine/api/hosts/123/forceselectspm ---- With a request body like this: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'forceselectspm', None, headers, query, wait) def get( self, all_content=None, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the host details. [source] ---- GET /ovirt-engine/api/hosts/123 ---- This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `all_content`:: 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. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def install( self, activate=None, async_=None, deploy_hosted_engine=None, host=None, image=None, reboot=None, root_password=None, ssh=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ 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: [source,bash] ---- 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: [source,bash] ---- 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" "deploy_hosted_engine" : "true" } ' \ "https://engine.example.com/ovirt-engine/api/hosts/123" ---- IMPORTANT: Since version 4.1.2 of the engine, when a host is reinstalled we override the host firewall definitions by default. This method supports the following parameters: `activate`:: When set to 'true', this host will be activated after its installation completes. When set to 'false' the host will remain in 'maintenance' status after its installation. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after install. `root_password`:: The password of the `root` user used to connect to the host via SSH. `ssh`:: The SSH details used to connect to the host. `host`:: The `override_iptables` property is used to indicate if the firewall configuration should be replaced by the default one. `image`:: When installing {hypervisor-name}, an ISO image file is required. `async_`:: Indicates if the installation should be performed asynchronously. `deploy_hosted_engine`:: When set to `true` this host will also deploy the self-hosted engine components. A missing value is treated as `true` i.e deploy. Omitting this parameter means `false` and will not perform any operation in the self-hosted engine area. `undeploy_hosted_engine`:: When set to `true` this host will 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 not perform any operation in the self-hosted engine area. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('host', host, types.Host), ('image', image, str), ('reboot', reboot, bool), ('root_password', root_password, str), ('ssh', ssh, types.Ssh), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, deploy_hosted_engine=deploy_hosted_engine, host=host, image=image, reboot=reboot, root_password=root_password, ssh=ssh, undeploy_hosted_engine=undeploy_hosted_engine, ) # Send the request and wait for the response: return self._internal_action(action, 'install', None, headers, query, wait) def iscsi_discover( self, async_=None, iscsi=None, headers=None, query=None, wait=True, **kwargs ): """ This method has been deprecated since Engine version 4.4.6. DiscoverIscsi should be used instead. Discovers iSCSI targets on the host, using the initiator details. Returns an array of strings containing the discovered data. For example, to discover iSCSI targets available in `myiscsi.example.com`, from host `123`, send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/iscsidiscover ---- With a request body like this: [source,xml] ---- <action> <iscsi> <address>myiscsi.example.com</address> </iscsi> </action> ---- This method supports the following parameters: `iscsi`:: The target iSCSI device. `async_`:: Indicates if the discovery should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('iscsi', iscsi, types.IscsiDetails), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, iscsi=iscsi, ) # Send the request and wait for the response: return self._internal_action(action, 'iscsidiscover', 'iscsi_targets', headers, query, wait) def iscsi_login( self, async_=None, iscsi=None, headers=None, query=None, wait=True, **kwargs ): """ Login to iSCSI targets on the host, using the target details. IMPORTANT: When using this method to log in, you must use the iscsi details from the discovered targets results in the discoveriscsi method. This method supports the following parameters: `iscsi`:: The target iSCSI device. `async_`:: Indicates if the login should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('iscsi', iscsi, types.IscsiDetails), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, iscsi=iscsi, ) # Send the request and wait for the response: return self._internal_action(action, 'iscsilogin', None, headers, query, wait) def refresh( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Refresh the host devices and capabilities. This method supports the following parameters: `async_`:: Indicates if the refresh should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'refresh', None, headers, query, wait) def remove( self, force=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the host from the system. [source] ---- #!/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" ---- This method supports the following parameters: `force`:: Indicates that the host should be removed even if it is non-responsive, or if it is part of a Gluster Storage cluster and has volume bricks on it. `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('force', force, bool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if force is not None: force = Writer.render_boolean(force) query['force'] = force if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait) def setup_networks( self, async_=None, check_connectivity=None, commit_on_success=None, connectivity_timeout=None, modified_bonds=None, modified_labels=None, modified_network_attachments=None, removed_bonds=None, removed_labels=None, removed_network_attachments=None, synchronized_network_attachments=None, headers=None, query=None, wait=True, **kwargs ): """ 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: [source] ---- #!/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> <ip_address_assignment> <assignment_method>static</assignment_method> <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: [source,xml] ---- <options name="mode" value="4"/> <options name="miimon" value="100"/> <ip address="192.168.122.10" netmask="255.255.255.0"/> ---- The same thing can be done using the Python SDK with the following code: [source,python] ---- # 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 <<services/host/methods/commit_net_config, commitnetconfig>>. IMPORTANT: Since {engine-name} 4.3, it is possible to also specify `commit_on_success` in the <<services/host/methods/setup_networks, setupnetworks>> request, in which case the new configuration is automatically saved in the {hypervisor-name} upon completing the setup and re-establishing connectivity between the {hypervisor-name} and {engine-name}, and without waiting for a separate <<services/host/methods/commit_net_config, commitnetconfig>> request. This method supports the following parameters: `synchronized_network_attachments`:: A list of network attachments that will be synchronized. `commit_on_success`:: Specifies whether to automatically save the configuration in the {hypervisor-name} upon completing the setup and re-establishing connectivity between the {hypervisor-name} and {engine-name}, and without waiting for a separate <<services/host/methods/commit_net_config, commitnetconfig>> request. The default value is `false`, which means that the configuration will not be saved automatically. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('check_connectivity', check_connectivity, bool), ('commit_on_success', commit_on_success, bool), ('connectivity_timeout', connectivity_timeout, int), ('modified_bonds', modified_bonds, list), ('modified_labels', modified_labels, list), ('modified_network_attachments', modified_network_attachments, list), ('removed_bonds', removed_bonds, list), ('removed_labels', removed_labels, list), ('removed_network_attachments', removed_network_attachments, list), ('synchronized_network_attachments', synchronized_network_attachments, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, check_connectivity=check_connectivity, commit_on_success=commit_on_success, connectivity_timeout=connectivity_timeout, modified_bonds=modified_bonds, modified_labels=modified_labels, modified_network_attachments=modified_network_attachments, removed_bonds=removed_bonds, removed_labels=removed_labels, removed_network_attachments=removed_network_attachments, synchronized_network_attachments=synchronized_network_attachments, ) # Send the request and wait for the response: return self._internal_action(action, 'setupnetworks', None, headers, query, wait) def sync_all_networks( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ To synchronize all networks on the host, send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/syncallnetworks ---- With a request body like this: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'syncallnetworks', None, headers, query, wait) def unregistered_storage_domains_discover( self, async_=None, iscsi=None, headers=None, query=None, wait=True, **kwargs ): """ Discovers the block Storage Domains which are candidates to be imported to the setup. For FCP no arguments are required. This method supports the following parameters: `async_`:: Indicates if the discovery should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('iscsi', iscsi, types.IscsiDetails), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, iscsi=iscsi, ) # Send the request and wait for the response: return self._internal_action(action, 'unregisteredstoragedomainsdiscover', 'storage_domains', headers, query, wait) def update( self, host, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the host properties. For example, to update a the kernel command line of a host send a request like this: [source] ---- PUT /ovirt-engine/api/hosts/123 ---- With request body like this: [source, xml] ---- <host> <os> <custom_kernel_cmdline>vfio_iommu_type1.allow_unsafe_interrupts=1</custom_kernel_cmdline> </os> </host> ---- """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(host, headers, query, wait) def upgrade( self, async_=None, image=None, reboot=None, timeout=None, headers=None, query=None, wait=True, **kwargs ): """ Upgrades VDSM and selected software on the host. This method supports the following parameters: `image`:: This property is no longer relevant, since Vintage Node is no longer supported, and has been deprecated. `reboot`:: Indicates if the host should be rebooted after the upgrade. By default the host is rebooted. NOTE: This parameter is ignored for {hypervisor-name}, which is always rebooted after the upgrade. `async_`:: Indicates if the upgrade should be performed asynchronously. `timeout`:: Upgrade timeout. The maximum time to wait for upgrade to finish in minutes. Default value is specified by `ANSIBLE_PLAYBOOK_EXEC_DEFAULT_TIMEOUT` configration option. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('image', image, str), ('reboot', reboot, bool), ('timeout', timeout, int), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, image=image, reboot=reboot, timeout=timeout, ) # Send the request and wait for the response: return self._internal_action(action, 'upgrade', None, headers, query, wait) def upgrade_check( self, headers=None, query=None, wait=True, **kwargs ): """ 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 <<services/host/methods/upgrade, upgrade>> host action. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'upgradecheck', None, headers, query, wait) def approve_using_root_password( self, activate=None, async_=None, cluster=None, host=None, reboot=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `host`:: The host to approve. `cluster`:: The cluster where the host will be added after it is approved. `async_`:: Indicates if the approval should be performed asynchronously. `activate`:: When set to 'true', this host will be activated after its approval completes. When set to 'false' the host will remain in 'maintenance' status after its approval. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after approval. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('host', host, types.Host), ('reboot', reboot, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, cluster=cluster, host=host, reboot=reboot, ) # Send the request and wait for the response: return self._internal_action(action, 'approve', None, headers, query, wait) def install_using_root_password( self, activate=None, async_=None, deploy_hosted_engine=None, host=None, image=None, reboot=None, root_password=None, ssh=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ 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. This method supports the following parameters: `activate`:: When set to 'true', this host will be activated after its installation completes. When set to 'false' the host will remain in 'maintenance' status after its installation. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after install. `root_password`:: The password of the `root` user used to connect to the host via SSH. `ssh`:: The SSH details used to connect to the host. `host`:: The `override_iptables` property is used to indicate if the firewall configuration should be replaced by the default one. `image`:: When installing {hypervisor-name}, an ISO image file is required. `async_`:: Indicates if the installation should be performed asynchronously. `deploy_hosted_engine`:: When set to `true` this host will also deploy the self-hosted engine components. A missing value is treated as `true` i.e deploy. Omitting this parameter means `false` and will not perform any operation in the self-hosted engine area. `undeploy_hosted_engine`:: When set to `true` this host will 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 not perform any operation in the self-hosted engine area. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('host', host, types.Host), ('image', image, str), ('reboot', reboot, bool), ('root_password', root_password, str), ('ssh', ssh, types.Ssh), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, deploy_hosted_engine=deploy_hosted_engine, host=host, image=image, reboot=reboot, root_password=root_password, ssh=ssh, undeploy_hosted_engine=undeploy_hosted_engine, ) # Send the request and wait for the response: return self._internal_action(action, 'install', None, headers, query, wait) def update_using_root_password( self, host, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified host in the system. This is deprecated and is provided only for backwards compatibility. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(host, headers, query, wait) def approve_using_ssh( self, activate=None, async_=None, cluster=None, host=None, reboot=None, headers=None, query=None, wait=True, **kwargs ): """ Approve the specified host to be added to the engine by using ssh authentication. This occurs when the host registers itself with the engine. This method supports the following parameters: `host`:: The host to approve. `cluster`:: The cluster where the host will be added after it is approved. `async_`:: Indicates if the approval should be performed asynchronously. `activate`:: When set to 'true', this host will be activated after its approval completes. When set to 'false' the host will remain in 'maintenance' status after its approval. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after approval. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('host', host, types.Host), ('reboot', reboot, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, cluster=cluster, host=host, reboot=reboot, ) # Send the request and wait for the response: return self._internal_action(action, 'approve', None, headers, query, wait) def install_using_ssh( self, activate=None, async_=None, deploy_hosted_engine=None, host=None, image=None, reboot=None, root_password=None, ssh=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ Install VDSM and other packages required to get the host ready to be used in the engine providing the SSH password. This method supports the following parameters: `activate`:: When set to 'true', this host will be activated after its installation completes. When set to 'false' the host will remain in 'maintenance' status after its installation. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after install. `root_password`:: The password of the `root` user used to connect to the host via SSH. `ssh`:: The SSH details used to connect to the host. `host`:: The `override_iptables` property is used to indicate if the firewall configuration should be replaced by the default one. `image`:: When installing {hypervisor-name}, an ISO image file is required. `async_`:: Indicates if the installation should be performed asynchronously. `deploy_hosted_engine`:: When set to `true` this host will also deploy the self-hosted engine components. A missing value is treated as `true` i.e deploy. Omitting this parameter means `false` and will not perform any operation in the self-hosted engine area. `undeploy_hosted_engine`:: When set to `true` this host will 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 not perform any operation in the self-hosted engine area. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('host', host, types.Host), ('image', image, str), ('reboot', reboot, bool), ('root_password', root_password, str), ('ssh', ssh, types.Ssh), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, deploy_hosted_engine=deploy_hosted_engine, host=host, image=image, reboot=reboot, root_password=root_password, ssh=ssh, undeploy_hosted_engine=undeploy_hosted_engine, ) # Send the request and wait for the response: return self._internal_action(action, 'install', None, headers, query, wait) def update_using_ssh( self, host, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the specified host in the system. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(host, headers, query, wait) def affinity_labels_service(self): """ List of scheduling labels assigned to this host. """ return AssignedAffinityLabelsService(self._connection, '%s/affinitylabels' % self._path) def devices_service(self): """ A reference to the host devices service. Use this service to view the devices of the host object. """ return HostDevicesService(self._connection, '%s/devices' % self._path) def external_network_provider_configurations_service(self): """ External network providers provisioned by the system on the host. """ return ExternalNetworkProviderConfigurationsService(self._connection, '%s/externalnetworkproviderconfigurations' % self._path) def fence_agents_service(self): """ A reference to the fence agents service. Use this service to manage fence and power management agents on the host object. """ return FenceAgentsService(self._connection, '%s/fenceagents' % self._path) def hooks_service(self): """ A reference to the host hooks service. Use this service to view the hooks available in the host object. """ return HostHooksService(self._connection, '%s/hooks' % self._path) def katello_errata_service(self): """ A reference to the service that can show the applicable errata available on the host. This information is taken from Katello. """ return KatelloErrataService(self._connection, '%s/katelloerrata' % self._path) def network_attachments_service(self): """ A reference to the network attachments service. You can use this service to attach Logical networks to host interfaces. """ return NetworkAttachmentsService(self._connection, '%s/networkattachments' % self._path) def nics_service(self): """ A reference to the service that manages the network interface devices on the host. """ return HostNicsService(self._connection, '%s/nics' % self._path) def numa_nodes_service(self): """ A reference to the service that manage NUMA nodes for the host. """ return HostNumaNodesService(self._connection, '%s/numanodes' % self._path) def permissions_service(self): """ A reference to the host permission service. Use this service to manage permissions on the host object. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def storage_service(self): """ A reference to the service that manages the host's storage. """ return HostStorageService(self._connection, '%s/storage' % self._path) def storage_connection_extensions_service(self): """ A reference to storage connection extensions. """ return StorageServerConnectionExtensionsService(self._connection, '%s/storageconnectionextensions' % self._path) def tags_service(self): """ A reference to the host tags service. Use this service to manage tags on the host object. """ return AssignedTagsService(self._connection, '%s/tags' % self._path) def unmanaged_networks_service(self): """ A reference to unmanaged networks. """ return UnmanagedNetworksService(self._connection, '%s/unmanagednetworks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'affinitylabels': return self.affinity_labels_service() if path.startswith('affinitylabels/'): return self.affinity_labels_service().service(path[15:]) if path == 'devices': return self.devices_service() if path.startswith('devices/'): return self.devices_service().service(path[8:]) if path == 'externalnetworkproviderconfigurations': return self.external_network_provider_configurations_service() if path.startswith('externalnetworkproviderconfigurations/'): return self.external_network_provider_configurations_service().service(path[38:]) if path == 'fenceagents': return self.fence_agents_service() if path.startswith('fenceagents/'): return self.fence_agents_service().service(path[12:]) if path == 'hooks': return self.hooks_service() if path.startswith('hooks/'): return self.hooks_service().service(path[6:]) if path == 'katelloerrata': return self.katello_errata_service() if path.startswith('katelloerrata/'): return self.katello_errata_service().service(path[14:]) if path == 'networkattachments': return self.network_attachments_service() if path.startswith('networkattachments/'): return self.network_attachments_service().service(path[19:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) if path == 'numanodes': return self.numa_nodes_service() if path.startswith('numanodes/'): return self.numa_nodes_service().service(path[10:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) if path == 'storage': return self.storage_service() if path.startswith('storage/'): return self.storage_service().service(path[8:]) if path == 'storageconnectionextensions': return self.storage_connection_extensions_service() if path.startswith('storageconnectionextensions/'): return self.storage_connection_extensions_service().service(path[28:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) if path == 'unmanagednetworks': return self.unmanaged_networks_service() if path.startswith('unmanagednetworks/'): return self.unmanaged_networks_service().service(path[18:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'HostService:%s' % self._path
A service to manage a host.
View Source
def __init__(self, connection, path): super(HostService, self).__init__(connection, path) self._affinity_labels_service = None self._devices_service = None self._external_network_provider_configurations_service = None self._fence_agents_service = None self._hooks_service = None self._katello_errata_service = None self._network_attachments_service = None self._nics_service = None self._numa_nodes_service = None self._permissions_service = None self._statistics_service = None self._storage_service = None self._storage_connection_extensions_service = None self._tags_service = None self._unmanaged_networks_service = None
Creates a new service that will use the given connection and path.
View Source
def activate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Activates the host for use, for example to run virtual machines. This method supports the following parameters: `async_`:: Indicates if the activation should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'activate', None, headers, query, wait)
Activates the host for use, for example to run virtual machines.
This method supports the following parameters:
async_:: Indicates if the activation should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
approve(
self,
activate=None,
async_=None,
cluster=None,
host=None,
reboot=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def approve( self, activate=None, async_=None, cluster=None, host=None, reboot=None, headers=None, query=None, wait=True, **kwargs ): """ 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. This method supports the following parameters: `host`:: The host to approve. `cluster`:: The cluster where the host will be added after it is approved. `async_`:: Indicates if the approval should be performed asynchronously. `activate`:: When set to 'true', this host will be activated after its approval completes. When set to 'false' the host will remain in 'maintenance' status after its approval. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after approval. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('host', host, types.Host), ('reboot', reboot, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, cluster=cluster, host=host, reboot=reboot, ) # Send the request and wait for the response: return self._internal_action(action, 'approve', None, headers, query, wait)
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.
This method supports the following parameters:
host:: The host to approve.
cluster:: The cluster where the host will be added after it is approved.
async_:: Indicates if the approval should be performed asynchronously.
activate:: When set to 'true', this host will be activated after its approval completes. When set to 'false'
the host will remain in 'maintenance' status after its approval. Absence of this parameter will be
interpreted as 'true', since the desired default behavior is activating the host after approval.
reboot:: Indicates if the host should be rebooted after successful installation. The default value is true.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def commit_net_config( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ 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: [source] ---- POST /ovirt-engine/api/hosts/123/commitnetconfig ---- With a request body like this: [source,xml] ---- <action/> ---- IMPORTANT: Since {engine-name} 4.3, it is possible to also specify `commit_on_success` in the <<services/host/methods/setup_networks, setupnetworks>> request, in which case the new configuration is automatically saved in the {hypervisor-name} upon completing the setup and re-establishing connectivity between the {hypervisor-name} and {engine-name}, and without waiting for a separate <<services/host/methods/commit_net_config, commitnetconfig>> request. This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'commitnetconfig', None, headers, query, wait)
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:
[source]
POST /ovirt-engine/api/hosts/123/commitnetconfig
With a request body like this:
[source,xml]
IMPORTANT: Since {engine-name} 4.3, it is possible to also specify commit_on_success in
the <
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
copy_host_networks(
self,
async_=None,
source_host=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def copy_host_networks( self, async_=None, source_host=None, headers=None, query=None, wait=True, **kwargs ): """ Copy the network configuration of the specified host to current host. IMPORTANT: Any network attachments that are not present on the source host will be erased from the target host by the copy operation. To copy networks from another host, send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/copyhostnetworks ---- With a request body like this: [source,xml] ---- <action> <source_host id="456"/> </action> ---- This method supports the following parameters: `source_host`:: The host to copy networks from. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('source_host', source_host, types.Host), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, source_host=source_host, ) # Send the request and wait for the response: return self._internal_action(action, 'copyhostnetworks', None, headers, query, wait)
Copy the network configuration of the specified host to current host. IMPORTANT: Any network attachments that are not present on the source host will be erased from the target host by the copy operation. To copy networks from another host, send a request like this:
[source]
POST /ovirt-engine/api/hosts/123/copyhostnetworks
With a request body like this:
[source,xml]
This method supports the following parameters:
source_host:: The host to copy networks from.
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
deactivate(
self,
async_=None,
reason=None,
stop_gluster_service=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def deactivate( self, async_=None, reason=None, stop_gluster_service=None, headers=None, query=None, wait=True, **kwargs ): """ Deactivates the host to perform maintenance tasks. This method supports the following parameters: `async_`:: Indicates if the deactivation should be performed asynchronously. `stop_gluster_service`:: 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`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('reason', reason, str), ('stop_gluster_service', stop_gluster_service, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, reason=reason, stop_gluster_service=stop_gluster_service, ) # Send the request and wait for the response: return self._internal_action(action, 'deactivate', None, headers, query, wait)
Deactivates the host to perform maintenance tasks.
This method supports the following parameters:
async_:: Indicates if the deactivation should be performed asynchronously.
stop_gluster_service:: 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:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
discover_iscsi(
self,
async_=None,
iscsi=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def discover_iscsi( self, async_=None, iscsi=None, headers=None, query=None, wait=True, **kwargs ): """ Discovers iSCSI targets on the host, using the initiator details. Returns a list of IscsiDetails objects containing the discovered data. For example, to discover iSCSI targets available in `myiscsi.example.com`, from host `123`, send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/discoveriscsi ---- With a request body like this: [source,xml] ---- <action> <iscsi> <address>myiscsi.example.com</address> </iscsi> </action> ---- The result will be like this: [source,xml] ---- <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> ---- IMPORTANT: When using this method to discover iscsi targets, you can use an FQDN or an IP address, but you must use the iscsi details from the discovered targets results to log in using the iscsilogin method. This method supports the following parameters: `iscsi`:: The target iSCSI device. `async_`:: Indicates if the discovery should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('iscsi', iscsi, types.IscsiDetails), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, iscsi=iscsi, ) # Send the request and wait for the response: return self._internal_action(action, 'discoveriscsi', 'discovered_targets', headers, query, wait)
Discovers iSCSI targets on the host, using the initiator details.
Returns a list of IscsiDetails objects containing the discovered data.
For example, to discover iSCSI targets available in myiscsi.example.com,
from host 123, send a request like this:
[source]
POST /ovirt-engine/api/hosts/123/discoveriscsi
With a request body like this:
[source,xml]
The result will be like this:
[source,xml]
IMPORTANT: When using this method to discover iscsi targets, you can use an FQDN or an IP address, but you must use the iscsi details from the discovered targets results to log in using the iscsilogin method.
This method supports the following parameters:
iscsi:: The target iSCSI device.
async_:: Indicates if the discovery should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def enroll_certificate( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Enrolls the certificate of the host. Useful in case you get a warning that it is about to expire or has already expired. This method supports the following parameters: `async_`:: Indicates if the enrollment should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'enrollcertificate', None, headers, query, wait)
Enrolls the certificate of the host. Useful in case you get a warning that it is about to expire or has already expired.
This method supports the following parameters:
async_:: Indicates if the enrollment should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
fence(
self,
async_=None,
fence_type=None,
maintenance_after_restart=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def fence( self, async_=None, fence_type=None, maintenance_after_restart=None, headers=None, query=None, wait=True, **kwargs ): """ Controls the host's power management device. For example, to start the host. This can be done via: [source] ---- #!/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" ---- This method supports the following parameters: `async_`:: Indicates if the fencing should be performed asynchronously. `maintenance_after_restart`:: Indicates if host should be put into maintenance after restart. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('fence_type', fence_type, str), ('maintenance_after_restart', maintenance_after_restart, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, fence_type=fence_type, maintenance_after_restart=maintenance_after_restart, ) # Send the request and wait for the response: return self._internal_action(action, 'fence', 'power_management', headers, query, wait)
Controls the host's power management device. For example, to start the host. This can be done via:
[source]
!/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 '
' "${url}/hosts/123/fence"
This method supports the following parameters:
async_:: Indicates if the fencing should be performed asynchronously.
maintenance_after_restart:: Indicates if host should be put into maintenance after restart.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def force_select_spm( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ To manually set a host as the storage pool manager (SPM). [source] ---- POST /ovirt-engine/api/hosts/123/forceselectspm ---- With a request body like this: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'forceselectspm', None, headers, query, wait)
To manually set a host as the storage pool manager (SPM).
[source]
POST /ovirt-engine/api/hosts/123/forceselectspm
With a request body like this:
[source,xml]
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
get(
self,
all_content=None,
filter=None,
follow=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def get( self, all_content=None, filter=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ Gets the host details. [source] ---- GET /ovirt-engine/api/hosts/123 ---- This method supports the following parameters: `filter`:: Indicates if the results should be filtered according to the permissions of the user. `all_content`:: 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. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('filter', filter, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if filter is not None: filter = Writer.render_boolean(filter) query['filter'] = filter if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
Gets the host details.
[source]
GET /ovirt-engine/api/hosts/123
This method supports the following parameters:
filter:: Indicates if the results should be filtered according to the permissions of the user.
all_content:: Indicates if all of the attributes of the host should be included in the response.
By default the following attributes are excluded:
hosted_engineFor 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.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
install(
self,
activate=None,
async_=None,
deploy_hosted_engine=None,
host=None,
image=None,
reboot=None,
root_password=None,
ssh=None,
undeploy_hosted_engine=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def install( self, activate=None, async_=None, deploy_hosted_engine=None, host=None, image=None, reboot=None, root_password=None, ssh=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ 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: [source,bash] ---- 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: [source,bash] ---- 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" "deploy_hosted_engine" : "true" } ' \ "https://engine.example.com/ovirt-engine/api/hosts/123" ---- IMPORTANT: Since version 4.1.2 of the engine, when a host is reinstalled we override the host firewall definitions by default. This method supports the following parameters: `activate`:: When set to 'true', this host will be activated after its installation completes. When set to 'false' the host will remain in 'maintenance' status after its installation. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after install. `root_password`:: The password of the `root` user used to connect to the host via SSH. `ssh`:: The SSH details used to connect to the host. `host`:: The `override_iptables` property is used to indicate if the firewall configuration should be replaced by the default one. `image`:: When installing {hypervisor-name}, an ISO image file is required. `async_`:: Indicates if the installation should be performed asynchronously. `deploy_hosted_engine`:: When set to `true` this host will also deploy the self-hosted engine components. A missing value is treated as `true` i.e deploy. Omitting this parameter means `false` and will not perform any operation in the self-hosted engine area. `undeploy_hosted_engine`:: When set to `true` this host will 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 not perform any operation in the self-hosted engine area. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('host', host, types.Host), ('image', image, str), ('reboot', reboot, bool), ('root_password', root_password, str), ('ssh', ssh, types.Ssh), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, deploy_hosted_engine=deploy_hosted_engine, host=host, image=image, reboot=reboot, root_password=root_password, ssh=ssh, undeploy_hosted_engine=undeploy_hosted_engine, ) # Send the request and wait for the response: return self._internal_action(action, 'install', None, headers, query, wait)
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:
[source,bash]
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:
[source,bash]
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" "deploy_hosted_engine" : "true" }
' "https://engine.example.com/ovirt-engine/api/hosts/123"
IMPORTANT: Since version 4.1.2 of the engine, when a host is reinstalled we override the host firewall definitions by default.
This method supports the following parameters:
activate:: When set to 'true', this host will be activated after its installation completes. When set to 'false'
the host will remain in 'maintenance' status after its installation. Absence of this parameter will be
interpreted as 'true', since the desired default behavior is activating the host after install.
root_password:: The password of the root user used to connect to the host via SSH.
ssh:: The SSH details used to connect to the host.
host:: The override_iptables property is used to indicate if the firewall configuration should be replaced by the
default one.
image:: When installing {hypervisor-name}, an ISO image file is required.
async_:: Indicates if the installation should be performed asynchronously.
deploy_hosted_engine:: When set to true this host will also deploy the self-hosted engine components. A missing value
is treated as true i.e deploy. Omitting this parameter means false and will not perform any operation in the
self-hosted engine area.
undeploy_hosted_engine:: When set to true this host will 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 not perform any operation in the self-hosted engine area.
reboot:: Indicates if the host should be rebooted after successful installation. The default value is true.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
iscsi_discover(
self,
async_=None,
iscsi=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def iscsi_discover( self, async_=None, iscsi=None, headers=None, query=None, wait=True, **kwargs ): """ This method has been deprecated since Engine version 4.4.6. DiscoverIscsi should be used instead. Discovers iSCSI targets on the host, using the initiator details. Returns an array of strings containing the discovered data. For example, to discover iSCSI targets available in `myiscsi.example.com`, from host `123`, send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/iscsidiscover ---- With a request body like this: [source,xml] ---- <action> <iscsi> <address>myiscsi.example.com</address> </iscsi> </action> ---- This method supports the following parameters: `iscsi`:: The target iSCSI device. `async_`:: Indicates if the discovery should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('iscsi', iscsi, types.IscsiDetails), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, iscsi=iscsi, ) # Send the request and wait for the response: return self._internal_action(action, 'iscsidiscover', 'iscsi_targets', headers, query, wait)
This method has been deprecated since Engine version 4.4.6.
DiscoverIscsi should be used instead.
Discovers iSCSI targets on the host, using the initiator details.
Returns an array of strings containing the discovered data.
For example, to discover iSCSI targets available in myiscsi.example.com,
from host 123, send a request like this:
[source]
POST /ovirt-engine/api/hosts/123/iscsidiscover
With a request body like this:
[source,xml]
This method supports the following parameters:
iscsi:: The target iSCSI device.
async_:: Indicates if the discovery should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def iscsi_login( self, async_=None, iscsi=None, headers=None, query=None, wait=True, **kwargs ): """ Login to iSCSI targets on the host, using the target details. IMPORTANT: When using this method to log in, you must use the iscsi details from the discovered targets results in the discoveriscsi method. This method supports the following parameters: `iscsi`:: The target iSCSI device. `async_`:: Indicates if the login should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('iscsi', iscsi, types.IscsiDetails), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, iscsi=iscsi, ) # Send the request and wait for the response: return self._internal_action(action, 'iscsilogin', None, headers, query, wait)
Login to iSCSI targets on the host, using the target details. IMPORTANT: When using this method to log in, you must use the iscsi details from the discovered targets results in the discoveriscsi method.
This method supports the following parameters:
iscsi:: The target iSCSI device.
async_:: Indicates if the login should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def refresh( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Refresh the host devices and capabilities. This method supports the following parameters: `async_`:: Indicates if the refresh should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'refresh', None, headers, query, wait)
Refresh the host devices and capabilities.
This method supports the following parameters:
async_:: Indicates if the refresh should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def remove( self, force=None, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Remove the host from the system. [source] ---- #!/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" ---- This method supports the following parameters: `force`:: Indicates that the host should be removed even if it is non-responsive, or if it is part of a Gluster Storage cluster and has volume bricks on it. `async_`:: Indicates if the remove should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('force', force, bool), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if force is not None: force = Writer.render_boolean(force) query['force'] = force if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: self._internal_remove(headers, query, wait)
Remove the host from the system.
[source]
!/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"
This method supports the following parameters:
force:: Indicates that the host should be removed even if it is non-responsive,
or if it is part of a Gluster Storage cluster and has volume bricks on it.
async_:: Indicates if the remove should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
setup_networks(
self,
async_=None,
check_connectivity=None,
commit_on_success=None,
connectivity_timeout=None,
modified_bonds=None,
modified_labels=None,
modified_network_attachments=None,
removed_bonds=None,
removed_labels=None,
removed_network_attachments=None,
synchronized_network_attachments=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def setup_networks( self, async_=None, check_connectivity=None, commit_on_success=None, connectivity_timeout=None, modified_bonds=None, modified_labels=None, modified_network_attachments=None, removed_bonds=None, removed_labels=None, removed_network_attachments=None, synchronized_network_attachments=None, headers=None, query=None, wait=True, **kwargs ): """ 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: [source] ---- #!/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> <ip_address_assignment> <assignment_method>static</assignment_method> <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: [source,xml] ---- <options name="mode" value="4"/> <options name="miimon" value="100"/> <ip address="192.168.122.10" netmask="255.255.255.0"/> ---- The same thing can be done using the Python SDK with the following code: [source,python] ---- # 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 <<services/host/methods/commit_net_config, commitnetconfig>>. IMPORTANT: Since {engine-name} 4.3, it is possible to also specify `commit_on_success` in the <<services/host/methods/setup_networks, setupnetworks>> request, in which case the new configuration is automatically saved in the {hypervisor-name} upon completing the setup and re-establishing connectivity between the {hypervisor-name} and {engine-name}, and without waiting for a separate <<services/host/methods/commit_net_config, commitnetconfig>> request. This method supports the following parameters: `synchronized_network_attachments`:: A list of network attachments that will be synchronized. `commit_on_success`:: Specifies whether to automatically save the configuration in the {hypervisor-name} upon completing the setup and re-establishing connectivity between the {hypervisor-name} and {engine-name}, and without waiting for a separate <<services/host/methods/commit_net_config, commitnetconfig>> request. The default value is `false`, which means that the configuration will not be saved automatically. `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('check_connectivity', check_connectivity, bool), ('commit_on_success', commit_on_success, bool), ('connectivity_timeout', connectivity_timeout, int), ('modified_bonds', modified_bonds, list), ('modified_labels', modified_labels, list), ('modified_network_attachments', modified_network_attachments, list), ('removed_bonds', removed_bonds, list), ('removed_labels', removed_labels, list), ('removed_network_attachments', removed_network_attachments, list), ('synchronized_network_attachments', synchronized_network_attachments, list), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, check_connectivity=check_connectivity, commit_on_success=commit_on_success, connectivity_timeout=connectivity_timeout, modified_bonds=modified_bonds, modified_labels=modified_labels, modified_network_attachments=modified_network_attachments, removed_bonds=removed_bonds, removed_labels=removed_labels, removed_network_attachments=removed_network_attachments, synchronized_network_attachments=synchronized_network_attachments, ) # Send the request and wait for the response: return self._internal_action(action, 'setupnetworks', None, headers, query, wait)
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:
[source]
!/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 '
' "${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:
[source,xml]
The same thing can be done using the Python SDK with the following code:
[source,python]
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 <commit_on_success in
the <
This method supports the following parameters:
synchronized_network_attachments:: A list of network attachments that will be synchronized.
commit_on_success:: Specifies whether to automatically save the configuration in the {hypervisor-name} upon completing
the setup and re-establishing connectivity between the {hypervisor-name} and {engine-name},
and without waiting for a separate <false, which means that the configuration will not be
saved automatically.
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def sync_all_networks( self, async_=None, headers=None, query=None, wait=True, **kwargs ): """ To synchronize all networks on the host, send a request like this: [source] ---- POST /ovirt-engine/api/hosts/123/syncallnetworks ---- With a request body like this: [source,xml] ---- <action/> ---- This method supports the following parameters: `async_`:: Indicates if the action should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, ) # Send the request and wait for the response: return self._internal_action(action, 'syncallnetworks', None, headers, query, wait)
To synchronize all networks on the host, send a request like this:
[source]
POST /ovirt-engine/api/hosts/123/syncallnetworks
With a request body like this:
[source,xml]
This method supports the following parameters:
async_:: Indicates if the action should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
unregistered_storage_domains_discover(
self,
async_=None,
iscsi=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def unregistered_storage_domains_discover( self, async_=None, iscsi=None, headers=None, query=None, wait=True, **kwargs ): """ Discovers the block Storage Domains which are candidates to be imported to the setup. For FCP no arguments are required. This method supports the following parameters: `async_`:: Indicates if the discovery should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('iscsi', iscsi, types.IscsiDetails), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, iscsi=iscsi, ) # Send the request and wait for the response: return self._internal_action(action, 'unregisteredstoragedomainsdiscover', 'storage_domains', headers, query, wait)
Discovers the block Storage Domains which are candidates to be imported to the setup. For FCP no arguments are required.
This method supports the following parameters:
async_:: Indicates if the discovery should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update( self, host, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the host properties. For example, to update a the kernel command line of a host send a request like this: [source] ---- PUT /ovirt-engine/api/hosts/123 ---- With request body like this: [source, xml] ---- <host> <os> <custom_kernel_cmdline>vfio_iommu_type1.allow_unsafe_interrupts=1</custom_kernel_cmdline> </os> </host> ---- """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(host, headers, query, wait)
Update the host properties. For example, to update a the kernel command line of a host send a request like this:
[source]
PUT /ovirt-engine/api/hosts/123
With request body like this:
[source, xml]
#
def
upgrade(
self,
async_=None,
image=None,
reboot=None,
timeout=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def upgrade( self, async_=None, image=None, reboot=None, timeout=None, headers=None, query=None, wait=True, **kwargs ): """ Upgrades VDSM and selected software on the host. This method supports the following parameters: `image`:: This property is no longer relevant, since Vintage Node is no longer supported, and has been deprecated. `reboot`:: Indicates if the host should be rebooted after the upgrade. By default the host is rebooted. NOTE: This parameter is ignored for {hypervisor-name}, which is always rebooted after the upgrade. `async_`:: Indicates if the upgrade should be performed asynchronously. `timeout`:: Upgrade timeout. The maximum time to wait for upgrade to finish in minutes. Default value is specified by `ANSIBLE_PLAYBOOK_EXEC_DEFAULT_TIMEOUT` configration option. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('image', image, str), ('reboot', reboot, bool), ('timeout', timeout, int), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, image=image, reboot=reboot, timeout=timeout, ) # Send the request and wait for the response: return self._internal_action(action, 'upgrade', None, headers, query, wait)
Upgrades VDSM and selected software on the host.
This method supports the following parameters:
image:: This property is no longer relevant, since Vintage Node is no longer supported, and has been deprecated.
reboot:: Indicates if the host should be rebooted after the upgrade.
By default the host is rebooted.
NOTE: This parameter is ignored for {hypervisor-name}, which is always rebooted after the upgrade.
async_:: Indicates if the upgrade should be performed asynchronously.
timeout:: Upgrade timeout.
The maximum time to wait for upgrade to finish in minutes.
Default value is specified by ANSIBLE_PLAYBOOK_EXEC_DEFAULT_TIMEOUT configration option.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def upgrade_check( self, headers=None, query=None, wait=True, **kwargs ): """ 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 <<services/host/methods/upgrade, upgrade>> host action. """ # Check the types of the parameters: Service._check_types([ ]) # Populate the action: action = types.Action( ) # Send the request and wait for the response: return self._internal_action(action, 'upgradecheck', None, headers, query, wait)
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
<
#
def
approve_using_root_password(
self,
activate=None,
async_=None,
cluster=None,
host=None,
reboot=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def approve_using_root_password( self, activate=None, async_=None, cluster=None, host=None, reboot=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `host`:: The host to approve. `cluster`:: The cluster where the host will be added after it is approved. `async_`:: Indicates if the approval should be performed asynchronously. `activate`:: When set to 'true', this host will be activated after its approval completes. When set to 'false' the host will remain in 'maintenance' status after its approval. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after approval. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('host', host, types.Host), ('reboot', reboot, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, cluster=cluster, host=host, reboot=reboot, ) # Send the request and wait for the response: return self._internal_action(action, 'approve', None, headers, query, wait)
This method supports the following parameters:
host:: The host to approve.
cluster:: The cluster where the host will be added after it is approved.
async_:: Indicates if the approval should be performed asynchronously.
activate:: When set to 'true', this host will be activated after its approval completes. When set to 'false'
the host will remain in 'maintenance' status after its approval. Absence of this parameter will be
interpreted as 'true', since the desired default behavior is activating the host after approval.
reboot:: Indicates if the host should be rebooted after successful installation. The default value is true.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
install_using_root_password(
self,
activate=None,
async_=None,
deploy_hosted_engine=None,
host=None,
image=None,
reboot=None,
root_password=None,
ssh=None,
undeploy_hosted_engine=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def install_using_root_password( self, activate=None, async_=None, deploy_hosted_engine=None, host=None, image=None, reboot=None, root_password=None, ssh=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ 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. This method supports the following parameters: `activate`:: When set to 'true', this host will be activated after its installation completes. When set to 'false' the host will remain in 'maintenance' status after its installation. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after install. `root_password`:: The password of the `root` user used to connect to the host via SSH. `ssh`:: The SSH details used to connect to the host. `host`:: The `override_iptables` property is used to indicate if the firewall configuration should be replaced by the default one. `image`:: When installing {hypervisor-name}, an ISO image file is required. `async_`:: Indicates if the installation should be performed asynchronously. `deploy_hosted_engine`:: When set to `true` this host will also deploy the self-hosted engine components. A missing value is treated as `true` i.e deploy. Omitting this parameter means `false` and will not perform any operation in the self-hosted engine area. `undeploy_hosted_engine`:: When set to `true` this host will 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 not perform any operation in the self-hosted engine area. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('host', host, types.Host), ('image', image, str), ('reboot', reboot, bool), ('root_password', root_password, str), ('ssh', ssh, types.Ssh), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, deploy_hosted_engine=deploy_hosted_engine, host=host, image=image, reboot=reboot, root_password=root_password, ssh=ssh, undeploy_hosted_engine=undeploy_hosted_engine, ) # Send the request and wait for the response: return self._internal_action(action, 'install', None, headers, query, wait)
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.
This method supports the following parameters:
activate:: When set to 'true', this host will be activated after its installation completes. When set to 'false'
the host will remain in 'maintenance' status after its installation. Absence of this parameter will be
interpreted as 'true', since the desired default behavior is activating the host after install.
root_password:: The password of the root user used to connect to the host via SSH.
ssh:: The SSH details used to connect to the host.
host:: The override_iptables property is used to indicate if the firewall configuration should be replaced by the
default one.
image:: When installing {hypervisor-name}, an ISO image file is required.
async_:: Indicates if the installation should be performed asynchronously.
deploy_hosted_engine:: When set to true this host will also deploy the self-hosted engine components. A missing value
is treated as true i.e deploy. Omitting this parameter means false and will not perform any operation in the
self-hosted engine area.
undeploy_hosted_engine:: When set to true this host will 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 not perform any operation in the self-hosted engine area.
reboot:: Indicates if the host should be rebooted after successful installation. The default value is true.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
update_using_root_password(
self,
host,
async_=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def update_using_root_password( self, host, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Update the specified host in the system. This is deprecated and is provided only for backwards compatibility. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(host, headers, query, wait)
Update the specified host in the system. This is deprecated and is provided only for backwards compatibility.
#
def
approve_using_ssh(
self,
activate=None,
async_=None,
cluster=None,
host=None,
reboot=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def approve_using_ssh( self, activate=None, async_=None, cluster=None, host=None, reboot=None, headers=None, query=None, wait=True, **kwargs ): """ Approve the specified host to be added to the engine by using ssh authentication. This occurs when the host registers itself with the engine. This method supports the following parameters: `host`:: The host to approve. `cluster`:: The cluster where the host will be added after it is approved. `async_`:: Indicates if the approval should be performed asynchronously. `activate`:: When set to 'true', this host will be activated after its approval completes. When set to 'false' the host will remain in 'maintenance' status after its approval. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after approval. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('cluster', cluster, types.Cluster), ('host', host, types.Host), ('reboot', reboot, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, cluster=cluster, host=host, reboot=reboot, ) # Send the request and wait for the response: return self._internal_action(action, 'approve', None, headers, query, wait)
Approve the specified host to be added to the engine by using ssh authentication. This occurs when the host registers itself with the engine.
This method supports the following parameters:
host:: The host to approve.
cluster:: The cluster where the host will be added after it is approved.
async_:: Indicates if the approval should be performed asynchronously.
activate:: When set to 'true', this host will be activated after its approval completes. When set to 'false'
the host will remain in 'maintenance' status after its approval. Absence of this parameter will be
interpreted as 'true', since the desired default behavior is activating the host after approval.
reboot:: Indicates if the host should be rebooted after successful installation. The default value is true.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
install_using_ssh(
self,
activate=None,
async_=None,
deploy_hosted_engine=None,
host=None,
image=None,
reboot=None,
root_password=None,
ssh=None,
undeploy_hosted_engine=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def install_using_ssh( self, activate=None, async_=None, deploy_hosted_engine=None, host=None, image=None, reboot=None, root_password=None, ssh=None, undeploy_hosted_engine=None, headers=None, query=None, wait=True, **kwargs ): """ Install VDSM and other packages required to get the host ready to be used in the engine providing the SSH password. This method supports the following parameters: `activate`:: When set to 'true', this host will be activated after its installation completes. When set to 'false' the host will remain in 'maintenance' status after its installation. Absence of this parameter will be interpreted as 'true', since the desired default behavior is activating the host after install. `root_password`:: The password of the `root` user used to connect to the host via SSH. `ssh`:: The SSH details used to connect to the host. `host`:: The `override_iptables` property is used to indicate if the firewall configuration should be replaced by the default one. `image`:: When installing {hypervisor-name}, an ISO image file is required. `async_`:: Indicates if the installation should be performed asynchronously. `deploy_hosted_engine`:: When set to `true` this host will also deploy the self-hosted engine components. A missing value is treated as `true` i.e deploy. Omitting this parameter means `false` and will not perform any operation in the self-hosted engine area. `undeploy_hosted_engine`:: When set to `true` this host will 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 not perform any operation in the self-hosted engine area. `reboot`:: Indicates if the host should be rebooted after successful installation. The default value is `true`. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('activate', activate, bool), ('async_', async_, bool), ('deploy_hosted_engine', deploy_hosted_engine, bool), ('host', host, types.Host), ('image', image, str), ('reboot', reboot, bool), ('root_password', root_password, str), ('ssh', ssh, types.Ssh), ('undeploy_hosted_engine', undeploy_hosted_engine, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( activate=activate, async_=async_, deploy_hosted_engine=deploy_hosted_engine, host=host, image=image, reboot=reboot, root_password=root_password, ssh=ssh, undeploy_hosted_engine=undeploy_hosted_engine, ) # Send the request and wait for the response: return self._internal_action(action, 'install', None, headers, query, wait)
Install VDSM and other packages required to get the host ready to be used in the engine providing the SSH password.
This method supports the following parameters:
activate:: When set to 'true', this host will be activated after its installation completes. When set to 'false'
the host will remain in 'maintenance' status after its installation. Absence of this parameter will be
interpreted as 'true', since the desired default behavior is activating the host after install.
root_password:: The password of the root user used to connect to the host via SSH.
ssh:: The SSH details used to connect to the host.
host:: The override_iptables property is used to indicate if the firewall configuration should be replaced by the
default one.
image:: When installing {hypervisor-name}, an ISO image file is required.
async_:: Indicates if the installation should be performed asynchronously.
deploy_hosted_engine:: When set to true this host will also deploy the self-hosted engine components. A missing value
is treated as true i.e deploy. Omitting this parameter means false and will not perform any operation in the
self-hosted engine area.
undeploy_hosted_engine:: When set to true this host will 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 not perform any operation in the self-hosted engine area.
reboot:: Indicates if the host should be rebooted after successful installation. The default value is true.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def update_using_ssh( self, host, async_=None, headers=None, query=None, wait=True, **kwargs ): """ Updates the specified host in the system. """ # Check the types of the parameters: Service._check_types([ ('host', host, types.Host), ('async_', async_, bool), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Build the URL: query = query or {} if async_ is not None: async_ = Writer.render_boolean(async_) query['async'] = async_ # Send the request and wait for the response: return self._internal_update(host, headers, query, wait)
Updates the specified host in the system.
View Source
def affinity_labels_service(self): """ List of scheduling labels assigned to this host. """ return AssignedAffinityLabelsService(self._connection, '%s/affinitylabels' % self._path)
List of scheduling labels assigned to this host.
View Source
def devices_service(self): """ A reference to the host devices service. Use this service to view the devices of the host object. """ return HostDevicesService(self._connection, '%s/devices' % self._path)
A reference to the host devices service. Use this service to view the devices of the host object.
View Source
def external_network_provider_configurations_service(self): """ External network providers provisioned by the system on the host. """ return ExternalNetworkProviderConfigurationsService(self._connection, '%s/externalnetworkproviderconfigurations' % self._path)
External network providers provisioned by the system on the host.
View Source
def fence_agents_service(self): """ A reference to the fence agents service. Use this service to manage fence and power management agents on the host object. """ return FenceAgentsService(self._connection, '%s/fenceagents' % self._path)
A reference to the fence agents service. Use this service to manage fence and power management agents on the host object.
View Source
def hooks_service(self): """ A reference to the host hooks service. Use this service to view the hooks available in the host object. """ return HostHooksService(self._connection, '%s/hooks' % self._path)
A reference to the host hooks service. Use this service to view the hooks available in the host object.
View Source
def katello_errata_service(self): """ A reference to the service that can show the applicable errata available on the host. This information is taken from Katello. """ return KatelloErrataService(self._connection, '%s/katelloerrata' % self._path)
A reference to the service that can show the applicable errata available on the host. This information is taken from Katello.
View Source
def network_attachments_service(self): """ A reference to the network attachments service. You can use this service to attach Logical networks to host interfaces. """ return NetworkAttachmentsService(self._connection, '%s/networkattachments' % self._path)
A reference to the network attachments service. You can use this service to attach Logical networks to host interfaces.
View Source
def nics_service(self): """ A reference to the service that manages the network interface devices on the host. """ return HostNicsService(self._connection, '%s/nics' % self._path)
A reference to the service that manages the network interface devices on the host.
View Source
def numa_nodes_service(self): """ A reference to the service that manage NUMA nodes for the host. """ return HostNumaNodesService(self._connection, '%s/numanodes' % self._path)
A reference to the service that manage NUMA nodes for the host.
View Source
def permissions_service(self): """ A reference to the host permission service. Use this service to manage permissions on the host object. """ return AssignedPermissionsService(self._connection, '%s/permissions' % self._path)
A reference to the host permission service. Use this service to manage permissions on the host object.
View Source
def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path)
View Source
def storage_service(self): """ A reference to the service that manages the host's storage. """ return HostStorageService(self._connection, '%s/storage' % self._path)
A reference to the service that manages the host's storage.
View Source
def storage_connection_extensions_service(self): """ A reference to storage connection extensions. """ return StorageServerConnectionExtensionsService(self._connection, '%s/storageconnectionextensions' % self._path)
A reference to storage connection extensions.
View Source
def unmanaged_networks_service(self): """ A reference to unmanaged networks. """ return UnmanagedNetworksService(self._connection, '%s/unmanagednetworks' % self._path)
A reference to unmanaged networks.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'affinitylabels': return self.affinity_labels_service() if path.startswith('affinitylabels/'): return self.affinity_labels_service().service(path[15:]) if path == 'devices': return self.devices_service() if path.startswith('devices/'): return self.devices_service().service(path[8:]) if path == 'externalnetworkproviderconfigurations': return self.external_network_provider_configurations_service() if path.startswith('externalnetworkproviderconfigurations/'): return self.external_network_provider_configurations_service().service(path[38:]) if path == 'fenceagents': return self.fence_agents_service() if path.startswith('fenceagents/'): return self.fence_agents_service().service(path[12:]) if path == 'hooks': return self.hooks_service() if path.startswith('hooks/'): return self.hooks_service().service(path[6:]) if path == 'katelloerrata': return self.katello_errata_service() if path.startswith('katelloerrata/'): return self.katello_errata_service().service(path[14:]) if path == 'networkattachments': return self.network_attachments_service() if path.startswith('networkattachments/'): return self.network_attachments_service().service(path[19:]) if path == 'nics': return self.nics_service() if path.startswith('nics/'): return self.nics_service().service(path[5:]) if path == 'numanodes': return self.numa_nodes_service() if path.startswith('numanodes/'): return self.numa_nodes_service().service(path[10:]) if path == 'permissions': return self.permissions_service() if path.startswith('permissions/'): return self.permissions_service().service(path[12:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) if path == 'storage': return self.storage_service() if path.startswith('storage/'): return self.storage_service().service(path[8:]) if path == 'storageconnectionextensions': return self.storage_connection_extensions_service() if path.startswith('storageconnectionextensions/'): return self.storage_connection_extensions_service().service(path[28:]) if path == 'tags': return self.tags_service() if path.startswith('tags/'): return self.tags_service().service(path[5:]) if path == 'unmanagednetworks': return self.unmanaged_networks_service() if path.startswith('unmanagednetworks/'): return self.unmanaged_networks_service().service(path[18:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class HostNicService(MeasurableService): """ A service to manage a network interface of a host. """ def __init__(self, connection, path): super(HostNicService, self).__init__(connection, path) self._link_layer_discovery_protocol_elements_service = None self._network_attachments_service = None self._network_labels_service = None self._statistics_service = None self._virtual_function_allowed_labels_service = None self._virtual_function_allowed_networks_service = None def get( self, all_content=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `all_content`:: Indicates if all of the attributes of the host network interface should be included in the response. By default the following attributes are excluded: - `virtual_functions_configuration` For example, to retrieve the complete representation network interface '456' of host '123': .... GET /ovirt-engine/api/hosts/123/nics/456?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. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def update_virtual_functions_configuration( self, async_=None, virtual_functions_configuration=None, headers=None, query=None, wait=True, **kwargs ): """ The action updates virtual function configuration in case the current resource represents an SR-IOV enabled NIC. The input should be consisted of at least one of the following properties: - `allNetworksAllowed` - `numberOfVirtualFunctions` Please see the `HostNicVirtualFunctionsConfiguration` type for the meaning of the properties. This method supports the following parameters: `async_`:: Indicates if the update should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('virtual_functions_configuration', virtual_functions_configuration, types.HostNicVirtualFunctionsConfiguration), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, virtual_functions_configuration=virtual_functions_configuration, ) # Send the request and wait for the response: return self._internal_action(action, 'updatevirtualfunctionsconfiguration', None, headers, query, wait) def link_layer_discovery_protocol_elements_service(self): """ A reference to information elements received by LLDP on the NIC. """ return LinkLayerDiscoveryProtocolService(self._connection, '%s/linklayerdiscoveryprotocolelements' % self._path) def network_attachments_service(self): """ Reference to the service that manages the network attachments assigned to this network interface. """ return NetworkAttachmentsService(self._connection, '%s/networkattachments' % self._path) def network_labels_service(self): """ Reference to the service that manages the network labels assigned to this network interface. """ return NetworkLabelsService(self._connection, '%s/networklabels' % self._path) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def virtual_function_allowed_labels_service(self): """ Retrieves sub-collection resource of network labels that are allowed on an the virtual functions in case that the current resource represents an SR-IOV physical function NIC. """ return NetworkLabelsService(self._connection, '%s/virtualfunctionallowedlabels' % self._path) def virtual_function_allowed_networks_service(self): """ Retrieves sub-collection resource of networks that are allowed on an the virtual functions in case that the current resource represents an SR-IOV physical function NIC. """ return VirtualFunctionAllowedNetworksService(self._connection, '%s/virtualfunctionallowednetworks' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'linklayerdiscoveryprotocolelements': return self.link_layer_discovery_protocol_elements_service() if path.startswith('linklayerdiscoveryprotocolelements/'): return self.link_layer_discovery_protocol_elements_service().service(path[35:]) if path == 'networkattachments': return self.network_attachments_service() if path.startswith('networkattachments/'): return self.network_attachments_service().service(path[19:]) if path == 'networklabels': return self.network_labels_service() if path.startswith('networklabels/'): return self.network_labels_service().service(path[14:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) if path == 'virtualfunctionallowedlabels': return self.virtual_function_allowed_labels_service() if path.startswith('virtualfunctionallowedlabels/'): return self.virtual_function_allowed_labels_service().service(path[29:]) if path == 'virtualfunctionallowednetworks': return self.virtual_function_allowed_networks_service() if path.startswith('virtualfunctionallowednetworks/'): return self.virtual_function_allowed_networks_service().service(path[31:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'HostNicService:%s' % self._path
A service to manage a network interface of a host.
View Source
def __init__(self, connection, path): super(HostNicService, self).__init__(connection, path) self._link_layer_discovery_protocol_elements_service = None self._network_attachments_service = None self._network_labels_service = None self._statistics_service = None self._virtual_function_allowed_labels_service = None self._virtual_function_allowed_networks_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, all_content=None, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `all_content`:: Indicates if all of the attributes of the host network interface should be included in the response. By default the following attributes are excluded: - `virtual_functions_configuration` For example, to retrieve the complete representation network interface '456' of host '123': .... GET /ovirt-engine/api/hosts/123/nics/456?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. `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('all_content', all_content, bool), ('follow', follow, str), ]) # Build the URL: query = query or {} if all_content is not None: all_content = Writer.render_boolean(all_content) query['all_content'] = all_content if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
all_content:: Indicates if all of the attributes of the host network interface should be included in the response.
By default the following attributes are excluded:
virtual_functions_configurationFor example, to retrieve the complete representation network interface '456' of host '123': .... GET /ovirt-engine/api/hosts/123/nics/456?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.
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
#
def
update_virtual_functions_configuration(
self,
async_=None,
virtual_functions_configuration=None,
headers=None,
query=None,
wait=True,
**kwargs
):
View Source
def update_virtual_functions_configuration( self, async_=None, virtual_functions_configuration=None, headers=None, query=None, wait=True, **kwargs ): """ The action updates virtual function configuration in case the current resource represents an SR-IOV enabled NIC. The input should be consisted of at least one of the following properties: - `allNetworksAllowed` - `numberOfVirtualFunctions` Please see the `HostNicVirtualFunctionsConfiguration` type for the meaning of the properties. This method supports the following parameters: `async_`:: Indicates if the update should be performed asynchronously. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('async_', async_, bool), ('virtual_functions_configuration', virtual_functions_configuration, types.HostNicVirtualFunctionsConfiguration), ]) # Since Python 3.7 async is reserved keyword, support backward compatibility if 'async' in kwargs: async_ = kwargs.get('async') # Populate the action: action = types.Action( async_=async_, virtual_functions_configuration=virtual_functions_configuration, ) # Send the request and wait for the response: return self._internal_action(action, 'updatevirtualfunctionsconfiguration', None, headers, query, wait)
The action updates virtual function configuration in case the current resource represents an SR-IOV enabled NIC. The input should be consisted of at least one of the following properties:
allNetworksAllowednumberOfVirtualFunctionsPlease see theHostNicVirtualFunctionsConfigurationtype for the meaning of the properties.
This method supports the following parameters:
async_:: Indicates if the update should be performed asynchronously.
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def link_layer_discovery_protocol_elements_service(self): """ A reference to information elements received by LLDP on the NIC. """ return LinkLayerDiscoveryProtocolService(self._connection, '%s/linklayerdiscoveryprotocolelements' % self._path)
A reference to information elements received by LLDP on the NIC.
View Source
def network_attachments_service(self): """ Reference to the service that manages the network attachments assigned to this network interface. """ return NetworkAttachmentsService(self._connection, '%s/networkattachments' % self._path)
Reference to the service that manages the network attachments assigned to this network interface.
View Source
def network_labels_service(self): """ Reference to the service that manages the network labels assigned to this network interface. """ return NetworkLabelsService(self._connection, '%s/networklabels' % self._path)
Reference to the service that manages the network labels assigned to this network interface.
View Source
def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path)
View Source
def virtual_function_allowed_labels_service(self): """ Retrieves sub-collection resource of network labels that are allowed on an the virtual functions in case that the current resource represents an SR-IOV physical function NIC. """ return NetworkLabelsService(self._connection, '%s/virtualfunctionallowedlabels' % self._path)
Retrieves sub-collection resource of network labels that are allowed on an the virtual functions in case that the current resource represents an SR-IOV physical function NIC.
View Source
def virtual_function_allowed_networks_service(self): """ Retrieves sub-collection resource of networks that are allowed on an the virtual functions in case that the current resource represents an SR-IOV physical function NIC. """ return VirtualFunctionAllowedNetworksService(self._connection, '%s/virtualfunctionallowednetworks' % self._path)
Retrieves sub-collection resource of networks that are allowed on an the virtual functions in case that the current resource represents an SR-IOV physical function NIC.
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'linklayerdiscoveryprotocolelements': return self.link_layer_discovery_protocol_elements_service() if path.startswith('linklayerdiscoveryprotocolelements/'): return self.link_layer_discovery_protocol_elements_service().service(path[35:]) if path == 'networkattachments': return self.network_attachments_service() if path.startswith('networkattachments/'): return self.network_attachments_service().service(path[19:]) if path == 'networklabels': return self.network_labels_service() if path.startswith('networklabels/'): return self.network_labels_service().service(path[14:]) if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) if path == 'virtualfunctionallowedlabels': return self.virtual_function_allowed_labels_service() if path.startswith('virtualfunctionallowedlabels/'): return self.virtual_function_allowed_labels_service().service(path[29:]) if path == 'virtualfunctionallowednetworks': return self.virtual_function_allowed_networks_service() if path.startswith('virtualfunctionallowednetworks/'): return self.virtual_function_allowed_networks_service().service(path[31:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.
View Source
class HostNumaNodeService(MeasurableService): """ """ def __init__(self, connection, path): super(HostNumaNodeService, self).__init__(connection, path) self._statistics_service = None def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait) def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path) def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path) def __str__(self): return 'HostNumaNodeService:%s' % self._path
View Source
def __init__(self, connection, path): super(HostNumaNodeService, self).__init__(connection, path) self._statistics_service = None
Creates a new service that will use the given connection and path.
View Source
def get( self, follow=None, headers=None, query=None, wait=True, **kwargs ): """ This method supports the following parameters: `follow`:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part of the current request. See <<documents/003_common_concepts/follow, here>> for details. `headers`:: Additional HTTP headers. `query`:: Additional URL query parameters. `wait`:: If `True` wait for the response. """ # Check the types of the parameters: Service._check_types([ ('follow', follow, str), ]) # Build the URL: query = query or {} if follow is not None: query['follow'] = follow # Send the request and wait for the response: return self._internal_get(headers, query, wait)
This method supports the following parameters:
follow:: Indicates which inner links should be _followed_. The objects referenced by these links will be fetched as part
of the current request. See <
headers:: Additional HTTP headers.
query:: Additional URL query parameters.
wait:: If True wait for the response.
View Source
def statistics_service(self): """ """ return StatisticsService(self._connection, '%s/statistics' % self._path)
View Source
def service(self, path): """ Service locator method, returns individual service on which the URI is dispatched. """ if not path: return self if path == 'statistics': return self.statistics_service() if path.startswith('statistics/'): return self.statistics_service().service(path[11:]) raise Error('The path \"%s\" doesn\'t correspond to any service' % path)
Service locator method, returns individual service on which the URI is dispatched.