def execute_module(self):
# Parse parameters specific for this module:
self.client = self.get_api_client()
definition = virtdict()
ephemeral = self.params.get('ephemeral')
state = self.params.get('state')
if not ephemeral:
definition['spec']['running'] = state == 'running'
# Construct the API object definition:
vm_template = self.params.get('template')
processedtemplate = {}
if vm_template:
# Find the template the VM should be created from:
template_resource = self.client.resources.get(
api_version='template.openshift.io/v1',
kind='Template',
name='templates')
proccess_template = template_resource.get(
name=vm_template, namespace=self.params.get('namespace'))
# Set proper template values set by Ansible parameter 'parameters':
for k, v in self.params.get('parameters', {}).items():
for parameter in proccess_template.parameters:
if parameter.name == k:
parameter.value = v
# Proccess the template:
processedtemplates_res = self.client.resources.get(
api_version='template.openshift.io/v1',
kind='Template',
name='processedtemplates')
processedtemplate = processedtemplates_res.create(
proccess_template.to_dict()).to_dict()['objects'][0]
template = definition if ephemeral else definition['spec']['template']
kind = 'VirtualMachineInstance' if ephemeral else 'VirtualMachine'
template['labels']['vm.cnv.io/name'] = self.params.get('name')
dummy, definition = self.construct_vm_definition(
kind, definition, template)
definition = dict(self.merge_dicts(processedtemplate, definition))
# Create the VM:
result = self.execute_crud(kind, definition)
changed = result['changed']
# Manage state of the VM:
if state in ['running', 'stopped']:
if not self.check_mode:
ret = self.manage_state(state)
changed = changed or ret
# Return from the module:
self.exit_json(
**{
'changed': changed,
'kubevirt_vm': result.pop('result'),
'result': result,
})
def execute_module(self):
# Parse parameters specific for this module:
definition = virtdict()
ephemeral = self.params.get('ephemeral')
state = self.params.get('state')
if not ephemeral:
definition['spec']['running'] = state == 'running'
# Execute the CURD of VM:
template = definition if ephemeral else definition['spec']['template']
kind = 'VirtualMachineInstance' if ephemeral else 'VirtualMachine'
dummy, definition = self.construct_vm_definition(
kind, definition, template)
result = self.execute_crud(kind, definition)
changed = result['changed']
# Manage state of the VM:
if state in ['running', 'stopped']:
if not self.check_mode:
ret = self.manage_state(state)
changed = changed or ret
# Return from the module:
self.exit_json(
**{
'changed': changed,
'kubevirt_vm': result.pop('result'),
'result': result,
})
def execute_module(self):
# Parse parameters specific for this module:
definition = virtdict()
selector = self.params.get('selector')
replicas = self.params.get('replicas')
if selector:
definition['spec']['selector'] = selector
if replicas is not None:
definition['spec']['replicas'] = replicas
# Execute the CURD of VM:
template = definition['spec']['template']
dummy, definition = self.construct_vm_definition(
KIND, definition, template)
result_crud = self.execute_crud(KIND, definition)
changed = result_crud['changed']
result = result_crud.pop('result')
# Wait for the replicas:
wait = self.params.get('wait')
if wait:
result = self.wait_for_replicas()
# Return from the module:
self.exit_json(**{
'changed': changed,
'kubevirt_rs': result,
'result': result_crud,
})
def construct_definition(self, kind, our_state, ephemeral):
definition = virtdict()
processedtemplate = {}
# Construct the API object definition:
defaults = {'disks': [], 'volumes': [], 'interfaces': [], 'networks': []}
vm_template = self.params.get('template')
if vm_template:
# Find the template the VM should be created from:
template_resource = self.client.resources.get(api_version='template.openshift.io/v1', kind='Template', name='templates')
proccess_template = template_resource.get(name=vm_template, namespace=self.params.get('namespace'))
# Set proper template values taken from module option 'template_parameters':
for k, v in self.params.get('template_parameters', {}).items():
for parameter in proccess_template.parameters:
if parameter.name == k:
parameter.value = v
# Proccess the template:
processedtemplates_res = self.client.resources.get(api_version='template.openshift.io/v1', kind='Template', name='processedtemplates')
processedtemplate = processedtemplates_res.create(proccess_template.to_dict()).to_dict()['objects'][0]
# Process defaults of the template:
self._process_template_defaults(proccess_template, processedtemplate, defaults)
if not ephemeral:
definition['spec']['running'] = our_state == 'running'
template = definition if ephemeral else definition['spec']['template']
template['metadata']['labels']['vm.cnv.io/name'] = self.params.get('name')
dummy, definition = self.construct_vm_definition(kind, definition, template, defaults)
return self.merge_dicts(definition, processedtemplate)
def execute_module(self):
# Parse parameters specific for this module:
definition = virtdict()
selector = self.params.get('selector')
if selector:
definition['spec']['selector'] = selector
# FIXME: Devices must be set, but we don't yet support any
# attributes there, remove when we do:
definition['spec']['domain']['devices'] = dict()
# defaults for template
defaults = {
'disks': [],
'volumes': [],
'interfaces': [],
'networks': []
}
# Execute the CURD of VM:
dummy, definition = self.construct_vm_definition(
KIND, definition, definition, defaults)
result_crud = self.execute_crud(KIND, definition)
changed = result_crud['changed']
result = result_crud.pop('result')
# Return from the module:
self.exit_json(**{
'changed': changed,
'kubevirt_preset': result,
'result': result_crud,
})
def execute_module(self):
# Parse parameters specific for this module:
definition = virtdict()
selector = self.params.get('selector')
replicas = self.params.get('replicas')
if selector:
definition['spec']['selector'] = selector
if replicas is not None:
definition['spec']['replicas'] = replicas
# defaults for template
defaults = {
'disks': [],
'volumes': [],
'interfaces': [],
'networks': []
}
# Execute the CURD of VM:
template = definition['spec']['template']
dummy, definition = self.construct_vm_definition(
KIND, definition, template, defaults)
result_crud = self.execute_crud(KIND, definition)
changed = result_crud['changed']
result = result_crud.pop('result')
# When creating a new VMIRS object without specifying `replicas`, assume it's '1' to make the
# wait logic work correctly
if changed and result_crud['method'] == 'create' and replicas is None:
replicas = 1
# Wait for the new number of ready replicas after a CRUD update
# Note1: doesn't work correctly when reducing number of replicas due to how VMIRS works (as of kubevirt 1.5.0)
# Note2: not the place to wait for the VMIs to get deleted when deleting the VMIRS object; that *might* be
# achievable in execute_crud(); keywords: orphanDependents, propagationPolicy, DeleteOptions
if self.params.get(
'wait') and replicas is not None and self.params.get(
'state') == 'present':
result = self.wait_for_replicas(replicas)
# Return from the module:
self.exit_json(**{
'changed': changed,
'kubevirt_rs': result,
'result': result_crud,
})
def execute_module(self):
KIND = 'PersistentVolumeClaim'
API = 'v1'
definition = virtdict()
definition['kind'] = KIND
definition['apiVersion'] = API
metadata = definition['metadata']
metadata['name'] = self.params.get('name')
metadata['namespace'] = self.params.get('namespace')
if self.params.get('annotations'):
metadata['annotations'] = self.params.get('annotations')
if self.params.get('labels'):
metadata['labels'] = self.params.get('labels')
if self.params.get('cdi_source'):
self._parse_cdi_source(self.params.get('cdi_source'), metadata)
spec = definition['spec']
if self.params.get('access_modes'):
spec['accessModes'] = self.params.get('access_modes')
if self.params.get('size'):
spec['resources']['requests']['storage'] = self.params.get('size')
if self.params.get('storage_class_name'):
spec['storageClassName'] = self.params.get('storage_class_name')
if self.params.get('selector'):
spec['selector'] = self.params.get('selector')
if self.params.get('volume_mode'):
spec['volumeMode'] = self.params.get('volume_mode')
if self.params.get('volume_name'):
spec['volumeName'] = self.params.get('volume_name')
# 'resource_definition:' has lower priority than module parameters
definition = dict(
KubeVirtRawModule.merge_dicts(definition,
self.resource_definitions[0]))
self.client = self.get_api_client()
resource = self.find_resource(KIND, API, fail=True)
definition = self.set_defaults(resource, definition)
result = self.perform_action(resource, definition)
if self.params.get('wait') and self.params.get('state') == 'present':
result['result'] = self._wait_for_creation(
resource, result['result']['metadata']['uid'])
self.exit_json(**result)
def execute_module(self):
# Parse parameters specific for this module:
definition = virtdict()
# Execute the CRUD of VM template:
kind = 'Template'
# Fill in template parameters:
definition['parameters'] = self.params.get('parameters')
# Fill in Openshift/Kubevirt template annotations:
annotations = definition['metadata']['annotations']
if self.params.get('display_name'):
annotations['openshift.io/display-name'] = self.params.get(
'display_name')
if self.params.get('description'):
annotations['description'] = self.params.get('description')
if self.params.get('long_description'):
annotations['openshift.io/long-description'] = self.params.get(
'long_description')
if self.params.get('provider_display_name'):
annotations[
'openshift.io/provider-display-name'] = self.params.get(
'provider_display_name')
if self.params.get('documentation_url'):
annotations['openshift.io/documentation-url'] = self.params.get(
'documentation_url')
if self.params.get('support_url'):
annotations['openshift.io/support-url'] = self.params.get(
'support_url')
if self.params.get('icon_class'):
annotations['iconClass'] = self.params.get('icon_class')
if self.params.get('version'):
annotations['template.cnv.io/version'] = self.params.get('version')
# TODO: Make it more Ansiblish, so user don't have to specify API JSON path, but rather Ansible params:
if self.params.get('editable'):
annotations['template.cnv.io/editable'] = self.params.get(
'editable')
# Set defaults annotations:
if self.params.get('default_disk'):
annotations['defaults.template.cnv.io/disk'] = self.params.get(
'default_disk').get('name')
if self.params.get('default_volume'):
annotations['defaults.template.cnv.io/volume'] = self.params.get(
'default_volume').get('name')
if self.params.get('default_nic'):
annotations['defaults.template.cnv.io/nic'] = self.params.get(
'default_nic').get('name')
if self.params.get('default_network'):
annotations['defaults.template.cnv.io/network'] = self.params.get(
'default_network').get('name')
# Proccess objects:
self.client = self.get_api_client()
definition['objects'] = []
objects = self.params.get('objects') or []
for obj in objects:
if obj['kind'] != 'VirtualMachine':
definition['objects'].append(obj)
else:
vm_definition = virtdict()
# Set VM defaults:
if self.params.get('default_disk'):
vm_definition['spec']['template']['spec']['domain'][
'devices']['disks'] = [
self.params.get('default_disk')
]
if self.params.get('default_volume'):
vm_definition['spec']['template']['spec']['volumes'] = [
self.params.get('default_volume')
]
if self.params.get('default_nic'):
vm_definition['spec']['template']['spec']['domain'][
'devices']['interfaces'] = [
self.params.get('default_nic')
]
if self.params.get('default_network'):
vm_definition['spec']['template']['spec']['networks'] = [
self.params.get('default_network')
]
# Set kubevirt API version:
vm_definition['apiVersion'] = MAX_SUPPORTED_API_VERSION
# Contruct k8s vm API object:
vm_template = vm_definition['spec']['template']
dummy, vm_def = self.construct_vm_template_definition(
'VirtualMachine', vm_definition, vm_template, obj)
definition['objects'].append(vm_def)
result = self.execute_crud(kind, definition)
# Return from the module:
self.exit_json(
**{
'changed': result['changed'],
'kubevirt_template': result.pop('result'),
'result': result,
})
