mirror of
https://opendev.org/openstack/ansible-collections-openstack.git
synced 2026-11-21 14:48:41 +00:00
The module documents and accepts import_method and uri, but nothing ever acts on them for a URL-based import. Its only import_image() call is hardcoded to glance-direct, so asking Glance to fetch an image itself is not possible. Worse, the two options are listed in attr_params, so they are handed to conn.create_image() as unrecognised keyword arguments and end up stored on the image as arbitrary properties. With no filename the create call then reaches the direct upload endpoint with no data, which Glance rejects: HttpException: 415: Client Error for url: .../v2/images/<id>/file, Unsupported Media Type Image disk_format qcow2 does not match stream data raw Import a queued image from its uri instead, defaulting the method to web-download, and drop the three behavioural options from attr_params so they stop becoming image properties. When creating the image, do not let create_image() wait for it to become active, since it stays queued until the import is started. Remove glance-download from the import_method choices. The module never used it. The glance-download method takes a remote region and a remote image ID, and the module has no options for these yet. Closes-Bug: #2167999 Change-Id: I11fa064567c36012cd51c78e4bca2c46152990d3 Signed-off-by: Moritz Tanner <moritz.tanner@linbit.com>
647 lines
22 KiB
Python
647 lines
22 KiB
Python
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# Copyright (c) 2015 Hewlett-Packard Development Company, L.P.
|
|
# Copyright (c) 2013, Benno Joy <benno@ansible.com>
|
|
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
|
|
|
|
DOCUMENTATION = r'''
|
|
module: image
|
|
short_description: Manage images of OpenStack image (Glance) service.
|
|
author: OpenStack Ansible SIG
|
|
description:
|
|
- Create or delete images in OpenStack image (Glance) service.
|
|
options:
|
|
checksum:
|
|
description:
|
|
- The checksum of the image.
|
|
type: str
|
|
container_format:
|
|
description:
|
|
- The format of the container.
|
|
- This image attribute cannot be changed.
|
|
- Examples are C(ami), C(aki), C(ari), C(bare), C(ovf), C(ova) or
|
|
C(docker).
|
|
default: bare
|
|
type: str
|
|
disk_format:
|
|
description:
|
|
- The format of the disk that is getting uploaded.
|
|
- This image attribute cannot be changed.
|
|
- Examples are C(ami), C(ari), C(aki), C(vhd), C(vmdk), C(raw),
|
|
C(qcow2), C(vdi), c(iso), C(vhdx) or C(ploop).
|
|
default: qcow2
|
|
type: str
|
|
filename:
|
|
description:
|
|
- The path to the file which has to be uploaded.
|
|
- This image attribute cannot be changed.
|
|
type: str
|
|
id:
|
|
description:
|
|
- The ID of the image when uploading an image.
|
|
- This image attribute cannot be changed.
|
|
type: str
|
|
is_protected:
|
|
description:
|
|
- Prevent image from being deleted.
|
|
aliases: ['protected']
|
|
type: bool
|
|
is_public:
|
|
description:
|
|
- Whether the image can be accessed publicly.
|
|
- Setting I(is_public) to C(true) requires admin role by default.
|
|
- I(is_public) has been deprecated. Use I(visibility) instead of
|
|
I(is_public).
|
|
type: bool
|
|
default: false
|
|
kernel:
|
|
description:
|
|
- The name of an existing kernel image that will be associated with this
|
|
image.
|
|
type: str
|
|
min_disk:
|
|
description:
|
|
- The minimum disk space (in GB) required to boot this image.
|
|
type: int
|
|
min_ram:
|
|
description:
|
|
- The minimum ram (in MB) required to boot this image.
|
|
type: int
|
|
name:
|
|
description:
|
|
- The name of the image when uploading - or the name/ID of the image if
|
|
deleting.
|
|
- If provided with the id, it can be used to change the name of existing
|
|
image.
|
|
required: true
|
|
type: str
|
|
owner:
|
|
description:
|
|
- The name or ID of the project owning the image.
|
|
type: str
|
|
aliases: ['project']
|
|
owner_domain:
|
|
description:
|
|
- The name or id of the domain the project owning the image belongs to.
|
|
- May be used to identify a unique project when providing a name to the
|
|
project argument and multiple projects with such name exist.
|
|
type: str
|
|
aliases: ['project_domain']
|
|
properties:
|
|
description:
|
|
- Additional properties to be associated with this image.
|
|
default: {}
|
|
type: dict
|
|
ramdisk:
|
|
description:
|
|
- The name of an existing ramdisk image that will be associated with this
|
|
image.
|
|
type: str
|
|
state:
|
|
description:
|
|
- Should the resource be present, absent or inactive.
|
|
choices: [present, absent, inactive]
|
|
default: present
|
|
type: str
|
|
tags:
|
|
description:
|
|
- List of tags to be applied to the image.
|
|
default: []
|
|
type: list
|
|
elements: str
|
|
visibility:
|
|
description:
|
|
- The image visibility.
|
|
type: str
|
|
choices: [public, private, shared, community]
|
|
volume:
|
|
description:
|
|
- ID of a volume to create an image from.
|
|
- The volume must be in AVAILABLE state.
|
|
- I(volume) has been deprecated. Use module M(openstack.cloud.volume)
|
|
instead.
|
|
type: str
|
|
use_import:
|
|
description:
|
|
- Use the 'glance-direct' method of the interoperable image import mechanism.
|
|
- Applies only to uploads from I(filename). I(import_method) does not
|
|
affect it.
|
|
- Should only be used when needed, such as when the user needs the cloud to
|
|
transform image format.
|
|
type: bool
|
|
import_method:
|
|
description:
|
|
- Interoperable image import method that the Image service uses to
|
|
download the image data.
|
|
- The only supported method is web-download. The Image service downloads
|
|
the image data from I(uri).
|
|
- If I(uri) is set and I(import_method) is not, the module uses
|
|
web-download.
|
|
- For glance-direct uploads from I(filename), use I(use_import).
|
|
type: str
|
|
choices: [web-download]
|
|
uri:
|
|
description:
|
|
- URL the Image service downloads the image data from.
|
|
- Requires I(import_method=web-download), which is the default when
|
|
I(uri) is given, and a Glance with that import method enabled.
|
|
- Mutually exclusive with I(filename) and I(volume). The image data
|
|
never passes through the Ansible controller.
|
|
type: str
|
|
|
|
extends_documentation_fragment:
|
|
- openstack.cloud.openstack
|
|
'''
|
|
|
|
EXAMPLES = r'''
|
|
- name: Have the Image service download an image itself
|
|
openstack.cloud.image:
|
|
cloud: devstack
|
|
name: cirros
|
|
container_format: bare
|
|
disk_format: qcow2
|
|
import_method: web-download
|
|
uri: https://download.cirros-cloud.net/0.6.2/cirros-0.6.2-x86_64-disk.img
|
|
|
|
- name: Upload an image from a local file named cirros-0.3.0-x86_64-disk.img
|
|
openstack.cloud.image:
|
|
cloud: devstack-admin
|
|
name: cirros
|
|
container_format: bare
|
|
disk_format: qcow2
|
|
state: present
|
|
filename: cirros-0.3.0-x86_64-disk.img
|
|
kernel: cirros-vmlinuz
|
|
ramdisk: cirros-initrd
|
|
tags:
|
|
- custom
|
|
properties:
|
|
cpu_arch: x86_64
|
|
distro: ubuntu
|
|
'''
|
|
|
|
RETURN = r'''
|
|
image:
|
|
description: Dictionary describing the Glance image.
|
|
returned: On success when I(state) is C(present) or C(inactive).
|
|
type: dict
|
|
contains:
|
|
id:
|
|
description: Unique UUID.
|
|
type: str
|
|
name:
|
|
description: Name given to the image.
|
|
type: str
|
|
status:
|
|
description: Image status.
|
|
type: str
|
|
architecture:
|
|
description: The CPU architecture that must be supported by
|
|
the hypervisor.
|
|
type: str
|
|
created_at:
|
|
description: Image created at timestamp.
|
|
type: str
|
|
container_format:
|
|
description: Container format of the image.
|
|
type: str
|
|
direct_url:
|
|
description: URL to access the image file kept in external store.
|
|
type: str
|
|
min_ram:
|
|
description: Min amount of RAM required for this image.
|
|
type: int
|
|
disk_format:
|
|
description: Disk format of the image.
|
|
type: str
|
|
file:
|
|
description: The URL for the virtual machine image file.
|
|
type: str
|
|
has_auto_disk_config:
|
|
description: If root partition on disk is automatically resized
|
|
before the instance boots.
|
|
type: bool
|
|
hash_algo:
|
|
description: The algorithm used to compute a secure hash of the
|
|
image data.
|
|
type: str
|
|
hash_value:
|
|
description: The hexdigest of the secure hash of the image data
|
|
computed using the algorithm whose name is the value of the
|
|
os_hash_algo property.
|
|
type: str
|
|
hw_cpu_cores:
|
|
description: Used to pin the virtual CPUs (vCPUs) of instances to
|
|
the host's physical CPU cores (pCPUs).
|
|
type: str
|
|
hw_cpu_policy:
|
|
description: The hexdigest of the secure hash of the image data.
|
|
type: str
|
|
hw_cpu_sockets:
|
|
description: Preferred number of sockets to expose to the guest.
|
|
type: str
|
|
hw_cpu_thread_policy:
|
|
description: Defines how hardware CPU threads in a simultaneous
|
|
multithreading-based (SMT) architecture be used.
|
|
type: str
|
|
hw_cpu_threads:
|
|
description: The preferred number of threads to expose to the guest.
|
|
type: str
|
|
hw_disk_bus:
|
|
description: Specifies the type of disk controller to attach disk
|
|
devices to.
|
|
type: str
|
|
hw_machine_type:
|
|
description: Enables booting an ARM system using the
|
|
specified machine type.
|
|
type: str
|
|
hw_qemu_guest_agent:
|
|
description: "A string boolean, which if 'true', QEMU guest agent
|
|
will be exposed to the instance."
|
|
type: str
|
|
hw_rng_model:
|
|
description: "Adds a random-number generator device to the image's
|
|
instances."
|
|
type: str
|
|
hw_scsi_model:
|
|
description: Enables the use of VirtIO SCSI (virtio-scsi) to
|
|
provide block device access for compute instances.
|
|
type: str
|
|
hw_video_model:
|
|
description: The video image driver used.
|
|
type: str
|
|
hw_video_ram:
|
|
description: Maximum RAM for the video image.
|
|
type: str
|
|
hw_vif_model:
|
|
description: Specifies the model of virtual network interface device to
|
|
use.
|
|
type: str
|
|
hw_watchdog_action:
|
|
description: Enables a virtual hardware watchdog device that
|
|
carries out the specified action if the server hangs.
|
|
type: str
|
|
hypervisor_type:
|
|
description: The hypervisor type.
|
|
type: str
|
|
instance_type_rxtx_factor:
|
|
description: Optional property allows created servers to have a
|
|
different bandwidth cap than that defined in the network
|
|
they are attached to.
|
|
type: str
|
|
instance_uuid:
|
|
description: For snapshot images, this is the UUID of the server
|
|
used to create this image.
|
|
type: str
|
|
is_hidden:
|
|
description: Controls whether an image is displayed in the default
|
|
image-list response
|
|
type: bool
|
|
is_hw_boot_menu_enabled:
|
|
description: Enables the BIOS bootmenu.
|
|
type: bool
|
|
is_hw_vif_multiqueue_enabled:
|
|
description: Enables the virtio-net multiqueue feature.
|
|
type: bool
|
|
kernel_id:
|
|
description: The ID of an image stored in the Image service that
|
|
should be used as the kernel when booting an AMI-style
|
|
image.
|
|
type: str
|
|
locations:
|
|
description: A list of URLs to access the image file in external store.
|
|
type: str
|
|
metadata:
|
|
description: The location metadata.
|
|
type: str
|
|
needs_config_drive:
|
|
description: Specifies whether the image needs a config drive.
|
|
type: bool
|
|
needs_secure_boot:
|
|
description: Whether Secure Boot is needed.
|
|
type: bool
|
|
os_admin_user:
|
|
description: The operating system admin username.
|
|
type: str
|
|
os_command_line:
|
|
description: The kernel command line to be used by libvirt driver.
|
|
type: str
|
|
os_distro:
|
|
description: The common name of the operating system distribution
|
|
in lowercase.
|
|
type: str
|
|
os_require_quiesce:
|
|
description: If true, require quiesce on snapshot via
|
|
QEMU guest agent.
|
|
type: str
|
|
os_shutdown_timeout:
|
|
description: Time for graceful shutdown.
|
|
type: str
|
|
os_type:
|
|
description: The operating system installed on the image.
|
|
type: str
|
|
os_version:
|
|
description: The operating system version as specified by
|
|
the distributor.
|
|
type: str
|
|
owner_id:
|
|
description: The ID of the owner, or project, of the image.
|
|
type: str
|
|
ramdisk_id:
|
|
description: The ID of image stored in the Image service that should
|
|
be used as the ramdisk when booting an AMI-style image.
|
|
type: str
|
|
schema:
|
|
description: URL for the schema describing a virtual machine image.
|
|
type: str
|
|
store:
|
|
description: Glance will attempt to store the disk image data in the
|
|
backing store indicated by the value of the header.
|
|
type: str
|
|
updated_at:
|
|
description: Image updated at timestamp.
|
|
type: str
|
|
url:
|
|
description: URL to access the image file kept in external store.
|
|
type: str
|
|
virtual_size:
|
|
description: The virtual size of the image.
|
|
type: str
|
|
vm_mode:
|
|
description: The virtual machine mode.
|
|
type: str
|
|
vmware_adaptertype:
|
|
description: The virtual SCSI or IDE controller used by the
|
|
hypervisor.
|
|
type: str
|
|
vmware_ostype:
|
|
description: Operating system installed in the image.
|
|
type: str
|
|
filters:
|
|
description: Additional properties associated with the image.
|
|
type: dict
|
|
min_disk:
|
|
description: Min amount of disk space required for this image.
|
|
type: int
|
|
is_protected:
|
|
description: Image protected flag.
|
|
type: bool
|
|
checksum:
|
|
description: Checksum for the image.
|
|
type: str
|
|
owner:
|
|
description: Owner for the image.
|
|
type: str
|
|
visibility:
|
|
description: Indicates who has access to the image.
|
|
type: str
|
|
size:
|
|
description: Size of the image.
|
|
type: int
|
|
tags:
|
|
description: List of tags assigned to the image
|
|
type: list
|
|
'''
|
|
|
|
from ansible_collections.openstack.cloud.plugins.module_utils.openstack import OpenStackModule
|
|
|
|
|
|
class ImageModule(OpenStackModule):
|
|
|
|
argument_spec = dict(
|
|
checksum=dict(),
|
|
container_format=dict(default='bare'),
|
|
disk_format=dict(default='qcow2'),
|
|
filename=dict(),
|
|
id=dict(),
|
|
is_protected=dict(type='bool', aliases=['protected']),
|
|
is_public=dict(type='bool', default=False),
|
|
kernel=dict(),
|
|
min_disk=dict(type='int'),
|
|
min_ram=dict(type='int'),
|
|
name=dict(required=True),
|
|
owner=dict(aliases=['project']),
|
|
owner_domain=dict(aliases=['project_domain']),
|
|
properties=dict(type='dict', default={}),
|
|
ramdisk=dict(),
|
|
state=dict(default='present', choices=['absent', 'present', 'inactive']),
|
|
tags=dict(type='list', default=[], elements='str'),
|
|
visibility=dict(choices=['public', 'private', 'shared', 'community']),
|
|
volume=dict(),
|
|
use_import=dict(type='bool'),
|
|
import_method=dict(choices=['web-download']),
|
|
uri=dict()
|
|
)
|
|
|
|
module_kwargs = dict(
|
|
mutually_exclusive=[
|
|
('filename', 'volume', 'uri'),
|
|
('visibility', 'is_public'),
|
|
],
|
|
required_if=[
|
|
('import_method', 'web-download', ['uri']),
|
|
],
|
|
)
|
|
|
|
# resource attributes obtainable directly from params
|
|
attr_params = ('id', 'name', 'filename', 'disk_format',
|
|
'container_format', 'wait', 'timeout', 'is_public',
|
|
'is_protected', 'min_disk', 'min_ram', 'volume', 'tags')
|
|
|
|
def _resolve_visibility(self):
|
|
"""resolve a visibility value to be compatible with older versions"""
|
|
if self.params['visibility']:
|
|
return self.params['visibility']
|
|
if self.params['is_public'] is not None:
|
|
return 'public' if self.params['is_public'] else 'private'
|
|
return None
|
|
|
|
def _build_params(self, owner):
|
|
params = {attr: self.params[attr] for attr in self.attr_params}
|
|
if owner:
|
|
params['owner_id'] = owner.id
|
|
params['visibility'] = self._resolve_visibility()
|
|
params = {k: v for k, v in params.items() if v is not None}
|
|
return params
|
|
|
|
def _return_value(self, image_name_or_id):
|
|
image = self.conn.image.find_image(image_name_or_id)
|
|
if image:
|
|
image = image.to_dict(computed=False)
|
|
return image
|
|
|
|
def _build_update(self, image):
|
|
update_payload = {'visibility': self._resolve_visibility()}
|
|
|
|
for k in ('is_protected', 'min_disk', 'min_ram'):
|
|
update_payload[k] = self.params[k]
|
|
|
|
for k in ('kernel', 'ramdisk'):
|
|
if not self.params[k]:
|
|
continue
|
|
k_id = '{0}_id'.format(k)
|
|
k_image = self.conn.image.find_image(
|
|
name_or_id=self.params[k], ignore_missing=False)
|
|
update_payload[k_id] = k_image.id
|
|
|
|
update_payload = {k: v for k, v in update_payload.items()
|
|
if v is not None and image[k] != v}
|
|
|
|
for p, v in self.params['properties'].items():
|
|
if p not in image or image[p] != v:
|
|
update_payload[p] = v
|
|
|
|
if (self.params['tags']
|
|
and set(image['tags']) != set(self.params['tags'])):
|
|
update_payload['tags'] = self.params['tags']
|
|
|
|
# If both name and id are defined,then we might change the name
|
|
if self.params['id'] and \
|
|
self.params['name'] and \
|
|
self.params['name'] != image['name']:
|
|
update_payload['name'] = self.params['name']
|
|
|
|
return update_payload
|
|
|
|
def _wait_for_image_active(self, image):
|
|
if not self.params['wait']:
|
|
return image
|
|
|
|
return self.sdk.resource.wait_for_status(
|
|
self.conn.image,
|
|
image,
|
|
status='active',
|
|
failures=['error', 'deleted', 'killed'],
|
|
wait=self.params['timeout'],
|
|
attribute='status')
|
|
|
|
def _import_image(self, image, method, **kwargs):
|
|
if not hasattr(self.conn.image, 'import_image'):
|
|
self.fail_json(
|
|
msg="The installed openstacksdk library does not support "
|
|
"image import operations.")
|
|
|
|
self.conn.image.import_image(image, method=method, **kwargs)
|
|
return self._wait_for_image_active(self.conn.get_image(image.id))
|
|
|
|
def run(self):
|
|
changed = False
|
|
image_name_or_id = self.params['id'] or self.params['name']
|
|
owner_name_or_id = self.params['owner']
|
|
owner_domain_name_or_id = self.params['owner_domain']
|
|
owner_filters = {}
|
|
if owner_domain_name_or_id:
|
|
owner_domain = self.conn.identity.find_domain(
|
|
owner_domain_name_or_id)
|
|
if owner_domain:
|
|
owner_filters['domain_id'] = owner_domain.id
|
|
else:
|
|
# else user may not be able to enumerate domains
|
|
owner_filters['domain_id'] = owner_domain_name_or_id
|
|
|
|
owner = None
|
|
if owner_name_or_id:
|
|
owner = self.conn.identity.find_project(
|
|
owner_name_or_id, ignore_missing=False, **owner_filters)
|
|
|
|
image = None
|
|
if image_name_or_id:
|
|
image = self.conn.get_image(
|
|
image_name_or_id,
|
|
filters={k: self.params[k]
|
|
for k in ['checksum'] if self.params[k] is not None})
|
|
|
|
changed = False
|
|
if self.params['state'] == 'present':
|
|
import_method = self.params['import_method']
|
|
if self.params['uri'] and not import_method:
|
|
import_method = 'web-download'
|
|
|
|
attrs = self._build_params(owner)
|
|
if not image:
|
|
# self.conn.image.create_image() cannot be used because it does
|
|
# not provide self.conn.create_image()'s volume parameter [0].
|
|
# [0] https://opendev.org/openstack/openstacksdk/src/commit/
|
|
# a41d04ea197439c2f134ce3554995693933a46ac/openstack/cloud/_image.py#L306
|
|
if import_method:
|
|
# Without data, the image stays queued until the import
|
|
# below starts. Waiting for it here times out.
|
|
attrs['wait'] = False
|
|
image = self.conn.create_image(**attrs)
|
|
changed = True
|
|
if not self.params['wait'] and not import_method:
|
|
self.exit_json(changed=changed,
|
|
image=self._return_value(image.id))
|
|
|
|
if image['status'] == 'deactivated':
|
|
self.conn.image.reactivate_image(image)
|
|
changed = True
|
|
elif image['status'] == 'queued':
|
|
if import_method == 'web-download':
|
|
image = self._import_image(
|
|
image, import_method, uri=self.params['uri'])
|
|
changed = True
|
|
elif (
|
|
self.params['filename']
|
|
and hasattr(self.conn.image, 'stage_image')):
|
|
self.conn.image.stage_image(
|
|
image, filename=self.params['filename'])
|
|
changed = True
|
|
elif self.params['filename']:
|
|
with open(self.params['filename'], 'rb') as image_data:
|
|
self.conn.image.upload_image(
|
|
container_format=self.params['container_format'],
|
|
disk_format=self.params['disk_format'],
|
|
data=image_data,
|
|
id=image.id,
|
|
name=image.name)
|
|
changed = True
|
|
image = self.conn.get_image(image.id)
|
|
|
|
if image['status'] == 'uploading' and self.params['use_import']:
|
|
image = self._import_image(image, 'glance-direct')
|
|
changed = True
|
|
elif image['status'] == 'importing':
|
|
image = self._wait_for_image_active(image)
|
|
|
|
update_payload = self._build_update(image)
|
|
|
|
if update_payload:
|
|
self.conn.image.update_image(image.id, **update_payload)
|
|
changed = True
|
|
|
|
self.exit_json(changed=changed, image=self._return_value(image.id))
|
|
|
|
elif self.params['state'] == 'absent' and image is not None:
|
|
# self.conn.image.delete_image() does not offer a wait parameter
|
|
self.conn.delete_image(
|
|
name_or_id=image['id'],
|
|
wait=self.params['wait'],
|
|
timeout=self.params['timeout'])
|
|
changed = True
|
|
|
|
elif self.params['state'] == 'inactive' and image is not None:
|
|
if image['status'] == 'active':
|
|
self.conn.image.deactivate_image(image)
|
|
changed = True
|
|
|
|
update_payload = self._build_update(image)
|
|
|
|
if update_payload:
|
|
self.conn.image.update_image(image.id, **update_payload)
|
|
changed = True
|
|
|
|
self.exit_json(changed=changed, image=self._return_value(image.id))
|
|
|
|
self.exit_json(changed=changed)
|
|
|
|
|
|
def main():
|
|
module = ImageModule()
|
|
module()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|