cmueller/ansible
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Remove incidental vmware tests (#72420)

Browse source 
* Add explicit tests for ansible.module_utils.common.network.is_mac

* Test missing ANSIBLE_CONFIG

* Add explicit inventory script tests

* Add explicit tests for _consume_options

* Adjust perms, remove extra file

* ci_complete ci_coverage

* remove incidental_inventory_vmware_vm_inventory

* ci_complete ci_coverage

* Remove incidental_script_inventory_vmware_inventory

* ci_complete ci_coverage

* Remove incidental_vmware_guest

* ci_complete ci_coverage

* Remove incidental_vmware_host_hyperthreading and incidental_vmware_prepare_tests

* ci_complete ci_coverage

* newline and comment about what the test is doing

* ci_complete ci_coverage
This commit is contained in:
Matt Martz 2020-11-02 17:00:17 -06:00 committed by GitHub
parent 64a809d2b6
commit ccc63abc8e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
85 changed files with 1085 additions and 9892 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
shippable.yml
View file

@ -139,7 +139,6 @@ matrix:
- env: T=i/aws/2.7/1
- env: T=i/aws/3.6/1
- env: T=i/vcenter//1
- env: T=i/tower//1
- env: T=i/cloud//1

1
test/integration/targets/common_network/aliases Normal file
View file

@ -0,0 +1 @@
shippable/posix/group5

4
test/integration/targets/common_network/tasks/main.yml Normal file
View file

@ -0,0 +1,4 @@
- assert:
that:
- '"00:00:00:a1:2b:cc" is is_mac'
- '"foo" is not is_mac'

14
test/integration/targets/common_network/test_plugins/is_mac.py Normal file
View file

@ -0,0 +1,14 @@
# Copyright: (c) 2020, Matt Martz <matt@sivel.net>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
from ansible.module_utils.common.network import is_mac
class TestModule(object):
def tests(self):
return {
'is_mac': is_mac,
}

10
test/integration/targets/config/runme.sh
View file

@ -9,7 +9,9 @@ ANSIBLE_TIMEOUT= ansible -m ping testhost -i ../../inventory "$@"
# env var is wrong type, this should be a fatal error pointing at the setting
ANSIBLE_TIMEOUT='lola' ansible -m ping testhost -i ../../inventory "$@" 2>&1|grep 'Invalid type for configuration option setting: DEFAULT_TIMEOUT'
# https://github.com/ansible/ansible/issues/69577
ANSIBLE_REMOTE_TMP="$HOME/.ansible/directory_with_no_space" ansible -m ping testhost -i ../../inventory "$@"
ANSIBLE_REMOTE_TMP="$HOME/.ansible/directory with space" ansible -m ping testhost -i ../../inventory "$@"
# https://github.com/ansible/ansible/issues/69577
ANSIBLE_REMOTE_TMP="$HOME/.ansible/directory_with_no_space" ansible -m ping testhost -i ../../inventory "$@"
ANSIBLE_REMOTE_TMP="$HOME/.ansible/directory with space" ansible -m ping testhost -i ../../inventory "$@"
ANSIBLE_CONFIG=nonexistent.cfg ansible-config dump --only-changed -v | grep 'No config file found; using defaults'

3
test/integration/targets/incidental_inventory_vmware_vm_inventory/aliases
View file

@ -1,3 +0,0 @@
shippable/vcenter/incidental
cloud/vcenter
destructive

8
test/integration/targets/incidental_inventory_vmware_vm_inventory/ansible.cfg
View file

@ -1,8 +0,0 @@
[defaults]
inventory = test-config.vmware.yaml
[inventory]
enable_plugins = vmware_vm_inventory
cache = True
cache_plugin = jsonfile
cache_connection = inventory_cache

83
test/integration/targets/incidental_inventory_vmware_vm_inventory/runme.sh
View file

@ -1,83 +0,0 @@
#!/usr/bin/env bash
[[ -n "$DEBUG" || -n "$ANSIBLE_DEBUG" ]] && set -x
set -euo pipefail
# Required to differentiate between Python 2 and 3 environ
PYTHON=${ANSIBLE_TEST_PYTHON_INTERPRETER:-python}
export ANSIBLE_CONFIG=ansible.cfg
export VMWARE_SERVER="${VCENTER_HOSTNAME}"
export VMWARE_USERNAME="${VCENTER_USERNAME}"
export VMWARE_PASSWORD="${VCENTER_PASSWORD}"
port=5000
VMWARE_CONFIG=test-config.vmware.yaml
inventory_cache="$(pwd)/inventory_cache"
cat > "$VMWARE_CONFIG" <<VMWARE_YAML
plugin: vmware_vm_inventory
strict: False
validate_certs: False
with_tags: False
VMWARE_YAML
cleanup() {
echo "Cleanup"
if [ -f "${VMWARE_CONFIG}" ]; then
rm -f "${VMWARE_CONFIG}"
fi
if [ -d "${inventory_cache}" ]; then
echo "Removing ${inventory_cache}"
rm -rf "${inventory_cache}"
fi
echo "Done"
exit 0
}
trap cleanup INT TERM EXIT
echo "DEBUG: Using ${VCENTER_HOSTNAME} with username ${VCENTER_USERNAME} and password ${VCENTER_PASSWORD}"
echo "Kill all previous instances"
curl "http://${VCENTER_HOSTNAME}:${port}/killall" > /dev/null 2>&1
echo "Start new VCSIM server"
curl "http://${VCENTER_HOSTNAME}:${port}/spawn?datacenter=1&cluster=1&folder=0" > /dev/null 2>&1
echo "Debugging new instances"
curl "http://${VCENTER_HOSTNAME}:${port}/govc_find"
# Get inventory
ansible-inventory -i ${VMWARE_CONFIG} --list
echo "Check if cache is working for inventory plugin"
if [ ! -n "$(find "${inventory_cache}" -maxdepth 1 -name 'vmware_vm_inventory_*' -print -quit)" ]; then
echo "Cache directory not found. Please debug"
exit 1
fi
echo "Cache is working"
# Get inventory using YAML
ansible-inventory -i ${VMWARE_CONFIG} --list --yaml
# Install TOML for --toml
${PYTHON} -m pip freeze | grep toml > /dev/null 2>&1
TOML_TEST_RESULT=$?
if [ $TOML_TEST_RESULT -ne 0 ]; then
echo "Installing TOML package"
${PYTHON} -m pip install toml
else
echo "TOML package already exists, skipping installation"
fi
# Get inventory using TOML
ansible-inventory -i ${VMWARE_CONFIG} --list --toml
TOML_INVENTORY_LIST_RESULT=$?
if [ $TOML_INVENTORY_LIST_RESULT -ne 0 ]; then
echo "Inventory plugin failed to list inventory host using --toml, please debug"
exit 1
fi
# Test playbook with given inventory
ansible-playbook -i ${VMWARE_CONFIG} test_vmware_vm_inventory.yml --connection=local "$@"

24
test/integration/targets/incidental_inventory_vmware_vm_inventory/test_vmware_vm_inventory.yml
View file

@ -1,24 +0,0 @@
# Test code for the vmware guest dynamic plugin module
# Copyright: (c) 2018, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
---
- name: Test VMware Guest Dynamic Inventroy Plugin
hosts: localhost
tasks:
- name: store the vcenter container ip
set_fact:
vcsim: "{{ lookup('env', 'VCENTER_HOSTNAME') }}"
- name: Check that there are 'all' and 'otherGuest' groups present in inventory
assert:
that: "'{{ item }}' in {{ groups.keys() | list }}"
with_items:
- all
- otherGuest
- name: Check if Hostname and other details are populated in hostvars
assert:
that:
- hostvars[item].name is defined
with_items: "{{ groups['all'] }}"

3
test/integration/targets/incidental_script_inventory_vmware_inventory/aliases
View file

@ -1,3 +0,0 @@
shippable/vcenter/incidental
cloud/vcenter
destructive

58
test/integration/targets/incidental_script_inventory_vmware_inventory/runme.sh
View file

@ -1,58 +0,0 @@
#!/usr/bin/env bash
[[ -n "$DEBUG" || -n "$ANSIBLE_DEBUG" ]] && set -x
set -euo pipefail
contrib_dir=$(pwd)
echo "DEBUG: using ${contrib_dir}"
export ANSIBLE_CONFIG=ansible.cfg
export VMWARE_SERVER="${VCENTER_HOSTNAME}"
export VMWARE_USERNAME="${VCENTER_USERNAME}"
export VMWARE_PASSWORD="${VCENTER_PASSWORD}"
VMWARE_CONFIG=${contrib_dir}/vmware_inventory.ini
trap cleanup INT TERM EXIT
# Remove default inventory config file
if [ -f "${VMWARE_CONFIG}" ];
then
echo "DEBUG: Creating backup of ${VMWARE_CONFIG}"
cp "${VMWARE_CONFIG}" "${VMWARE_CONFIG}.bk"
fi
cat > "${VMWARE_CONFIG}" <<VMWARE_INI
[vmware]
server=${VMWARE_SERVER}
username=${VMWARE_USERNAME}
password=${VMWARE_PASSWORD}
validate_certs=False
VMWARE_INI
function cleanup {
# Revert back to previous one
if [ -f "${VMWARE_CONFIG}.bk" ]; then
echo "DEBUG: Cleanup ${VMWARE_CONFIG}"
mv "${VMWARE_CONFIG}.bk" "${VMWARE_CONFIG}"
fi
}
echo "DEBUG: Using ${VCENTER_HOSTNAME} with username ${VCENTER_USERNAME} and password ${VCENTER_PASSWORD}"
echo "Kill all previous instances"
curl "http://${VCENTER_HOSTNAME}:5000/killall" > /dev/null 2>&1
echo "Start new VCSIM server"
curl "http://${VCENTER_HOSTNAME}:5000/spawn?datacenter=1&cluster=1&folder=0" > /dev/null 2>&1
echo "Debugging new instances"
curl "http://${VCENTER_HOSTNAME}:5000/govc_find"
# Get inventory
ansible-playbook -i ./vmware_inventory.sh "./test_vmware_inventory.yml" --connection=local "$@"
echo "DEBUG: Done"

18
test/integration/targets/incidental_script_inventory_vmware_inventory/test_vmware_inventory.yml
View file

@ -1,18 +0,0 @@
# Test code for the vmware guest contrib inventory
# Copyright: (c) 2018, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
---
- name: Test VMware guest contrib inventroy script
hosts: localhost
tasks:
- name: store the vcenter container ip
set_fact:
vcsim: "{{ lookup('env', 'VCENTER_HOSTNAME') }}"
- name: Check that groups present in inventory
assert:
that:
- "'{{item}}' in groups"
with_items:
- all

127
test/integration/targets/incidental_script_inventory_vmware_inventory/vmware_inventory.ini
View file

@ -1,127 +0,0 @@
# Ansible VMware external inventory script settings
[vmware]
# The resolvable hostname or ip address of the vsphere
server=vcenter
# The port for the vsphere API
#port=443
# The username with access to the vsphere API. This setting
# may also be defined via the VMWARE_USERNAME environment variable.
username=administrator@vsphere.local
# The password for the vsphere API. This setting
# may also be defined via the VMWARE_PASSWORD environment variable.
password=vmware
# Verify the server's SSL certificate
#validate_certs = True
# Specify the number of seconds to use the inventory cache before it is
# considered stale. If not defined, defaults to 0 seconds.
#cache_max_age = 3600
# Specify the directory used for storing the inventory cache. If not defined,
# caching will be disabled.
#cache_path = ~/.cache/ansible
# Max object level refers to the level of recursion the script will delve into
# the objects returned from pyvomi to find serializable facts. The default
# level of 0 is sufficient for most tasks and will be the most performant.
# Beware that the recursion can exceed python's limit (causing traceback),
# cause sluggish script performance and return huge blobs of facts.
# If you do not know what you are doing, leave this set to 1.
#max_object_level=1
# Lower the keynames for facts to make addressing them easier.
#lower_var_keys=True
# Don't retrieve and process some VMware attribute keys
# Default values permit to sanitize inventory meta and to improve a little bit
# performance by removing non-common group attributes.
#skip_keys = declaredalarmstate,disabledmethod,dynamicproperty,dynamictype,environmentbrowser,managedby,parent,childtype,resourceconfig
# Host alias for objects in the inventory. VMware allows duplicate VM names
# so they can not be considered unique. Use this setting to alter the alias
# returned for the hosts. Any atributes for the guest can be used to build
# this alias. The default combines the config name and the config uuid and
# expects that the ansible_host will be set by the host_pattern.
#alias_pattern={{ config.name + '_' + config.uuid }}
# Host pattern is the value set for ansible_host and ansible_ssh_host, which
# needs to be a hostname or ipaddress the ansible controlhost can reach.
#host_pattern={{ guest.ipaddress }}
# Host filters are a comma separated list of jinja patterns to remove
# non-matching hosts from the final result.
# EXAMPLES:
# host_filters={{ config.guestid == 'rhel7_64Guest' }}
# host_filters={{ config.cpuhotremoveenabled != False }},{{ runtime.maxmemoryusage >= 512 }}
# host_filters={{ config.cpuhotremoveenabled != False }},{{ runtime.maxmemoryusage >= 512 }}
# host_filters={{ runtime.powerstate == "poweredOn" }}
# host_filters={{ guest.gueststate == "notRunning" }}
# The default value is powerstate of virtual machine equal to "poweredOn". (Changed in version 2.5)
# Runtime state does not require to have vmware tools installed as compared to "guest.gueststate"
#host_filters={{ runtime.powerstate == "poweredOn" }}
# Groupby patterns enable the user to create groups via any possible jinja
# expression. The resulting value will the groupname and the host will be added
# to that group. Be careful to not make expressions that simply return True/False
# because those values will become the literal group name. The patterns can be
# comma delimited to create as many groups as necessary
#groupby_patterns={{ guest.guestid }},{{ 'templates' if config.template else 'guests'}}
# Group by custom fields will use VMware custom fields to generate hostgroups
# based on {{ custom_field_group_prefix }} + field_name + _ + field_value
# Set groupby_custom_field to True will enable this feature
# If custom field value is comma separated, multiple groups are created.
# Warning: This required max_object_level to be set to 2 or greater.
#groupby_custom_field = False
# You can customize prefix used by custom field hostgroups generation here.
# vmware_tag_ prefix is the default and consistent with ec2_tag_
#custom_field_group_prefix = vmware_tag_
# You can blacklist custom fields so that they are not included in the
# groupby_custom_field option. This is useful when you have custom fields that
# have values that are unique to individual hosts. Timestamps for example.
# The groupby_custom_field_excludes option should be a comma separated list of custom
# field keys to be blacklisted.
#groupby_custom_field_excludes=<custom_field_1>,<custom_field_2>,<custom_field_3>
# The script attempts to recurse into virtualmachine objects and serialize
# all available data. The serialization is comprehensive but slow. If the
# vcenter environment is large and the desired properties are known, create
# a 'properties' section in this config and make an arbitrary list of
# key=value settings where the value is a path to a specific property. If
# If this feature is enabled, be sure to fetch every property that is used
# in the jinja expressions defined above. For performance tuning, reduce
# the number of properties to the smallest amount possible and limit the
# use of properties that are not direct attributes of vim.VirtualMachine
#[properties]
#prop01=name
#prop02=config.cpuHotAddEnabled
#prop03=config.cpuHotRemoveEnabled
#prop04=config.instanceUuid
#prop05=config.hardware.numCPU
#prop06=config.template
#prop07=config.name
#prop08=guest.hostName
#prop09=guest.ipAddress
#prop10=guest.guestId
#prop11=guest.guestState
#prop12=runtime.maxMemoryUsage
# In order to populate `customValue` (virtual machine's custom attributes) inside hostvars,
# uncomment following property. Please see - https://github.com/ansible/ansible/issues/41395
#prop13=customValue

795
test/integration/targets/incidental_script_inventory_vmware_inventory/vmware_inventory.py
View file

@ -1,795 +0,0 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright (C): 2017, Ansible Project
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
# Requirements
# - pyvmomi >= 6.0.0.2016.4
# TODO:
# * more jq examples
# * optional folder hierarchy
"""
$ jq '._meta.hostvars[].config' data.json | head
{
"alternateguestname": "",
"instanceuuid": "5035a5cd-b8e8-d717-e133-2d383eb0d675",
"memoryhotaddenabled": false,
"guestfullname": "Red Hat Enterprise Linux 7 (64-bit)",
"changeversion": "2016-05-16T18:43:14.977925Z",
"uuid": "4235fc97-5ddb-7a17-193b-9a3ac97dc7b4",
"cpuhotremoveenabled": false,
"vpmcenabled": false,
"firmware": "bios",
"""
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type
import atexit
import datetime
import itertools
import json
import os
import re
import ssl
import sys
import uuid
from time import time
from jinja2 import Environment
from ansible.module_utils.six import integer_types, PY3
from ansible.module_utils.six.moves import configparser
try:
import argparse
except ImportError:
sys.exit('Error: This inventory script required "argparse" python module. Please install it or upgrade to python-2.7')
try:
from pyVmomi import vim, vmodl
from pyVim.connect import SmartConnect, Disconnect
except ImportError:
sys.exit("ERROR: This inventory script required 'pyVmomi' Python module, it was not able to load it")
def regex_match(s, pattern):
'''Custom filter for regex matching'''
reg = re.compile(pattern)
if reg.match(s):
return True
else:
return False
def select_chain_match(inlist, key, pattern):
'''Get a key from a list of dicts, squash values to a single list, then filter'''
outlist = [x[key] for x in inlist]
outlist = list(itertools.chain(*outlist))
outlist = [x for x in outlist if regex_match(x, pattern)]
return outlist
class VMwareMissingHostException(Exception):
pass
class VMWareInventory(object):
__name__ = 'VMWareInventory'
guest_props = False
instances = []
debug = False
load_dumpfile = None
write_dumpfile = None
maxlevel = 1
lowerkeys = True
config = None
cache_max_age = None
cache_path_cache = None
cache_path_index = None
cache_dir = None
server = None
port = None
username = None
password = None
validate_certs = True
host_filters = []
skip_keys = []
groupby_patterns = []
groupby_custom_field_excludes = []
safe_types = [bool, str, float, None] + list(integer_types)
iter_types = [dict, list]
bad_types = ['Array', 'disabledMethod', 'declaredAlarmState']
vimTableMaxDepth = {
"vim.HostSystem": 2,
"vim.VirtualMachine": 2,
}
custom_fields = {}
# use jinja environments to allow for custom filters
env = Environment()
env.filters['regex_match'] = regex_match
env.filters['select_chain_match'] = select_chain_match
# translation table for attributes to fetch for known vim types
vimTable = {
vim.Datastore: ['_moId', 'name'],
vim.ResourcePool: ['_moId', 'name'],
vim.HostSystem: ['_moId', 'name'],
}
@staticmethod
def _empty_inventory():
return {"_meta": {"hostvars": {}}}
def __init__(self, load=True):
self.inventory = VMWareInventory._empty_inventory()
if load:
# Read settings and parse CLI arguments
self.parse_cli_args()
self.read_settings()
# Check the cache
cache_valid = self.is_cache_valid()
# Handle Cache
if self.args.refresh_cache or not cache_valid:
self.do_api_calls_update_cache()
else:
self.debugl('loading inventory from cache')
self.inventory = self.get_inventory_from_cache()
def debugl(self, text):
if self.args.debug:
try:
text = str(text)
except UnicodeEncodeError:
text = text.encode('utf-8')
print('%s %s' % (datetime.datetime.now(), text))
def show(self):
# Data to print
self.debugl('dumping results')
data_to_print = None
if self.args.host:
data_to_print = self.get_host_info(self.args.host)
elif self.args.list:
# Display list of instances for inventory
data_to_print = self.inventory
return json.dumps(data_to_print, indent=2)
def is_cache_valid(self):
''' Determines if the cache files have expired, or if it is still valid '''
valid = False
if os.path.isfile(self.cache_path_cache):
mod_time = os.path.getmtime(self.cache_path_cache)
current_time = time()
if (mod_time + self.cache_max_age) > current_time:
valid = True
return valid
def do_api_calls_update_cache(self):
''' Get instances and cache the data '''
self.inventory = self.instances_to_inventory(self.get_instances())
self.write_to_cache(self.inventory)
def write_to_cache(self, data):
''' Dump inventory to json file '''
with open(self.cache_path_cache, 'w') as f:
f.write(json.dumps(data, indent=2))
def get_inventory_from_cache(self):
''' Read in jsonified inventory '''
jdata = None
with open(self.cache_path_cache, 'r') as f:
jdata = f.read()
return json.loads(jdata)
def read_settings(self):
''' Reads the settings from the vmware_inventory.ini file '''
scriptbasename = __file__
scriptbasename = os.path.basename(scriptbasename)
scriptbasename = scriptbasename.replace('.py', '')
defaults = {'vmware': {
'server': '',
'port': 443,
'username': '',
'password': '',
'validate_certs': True,
'ini_path': os.path.join(os.path.dirname(__file__), '%s.ini' % scriptbasename),
'cache_name': 'ansible-vmware',
'cache_path': '~/.ansible/tmp',
'cache_max_age': 3600,
'max_object_level': 1,
'skip_keys': 'declaredalarmstate,'
'disabledmethod,'
'dynamicproperty,'
'dynamictype,'
'environmentbrowser,'
'managedby,'
'parent,'
'childtype,'
'resourceconfig',
'alias_pattern': '{{ config.name + "_" + config.uuid }}',
'host_pattern': '{{ guest.ipaddress }}',
'host_filters': '{{ runtime.powerstate == "poweredOn" }}',
'groupby_patterns': '{{ guest.guestid }},{{ "templates" if config.template else "guests"}}',
'lower_var_keys': True,
'custom_field_group_prefix': 'vmware_tag_',
'groupby_custom_field_excludes': '',
'groupby_custom_field': False}
}
if PY3:
config = configparser.ConfigParser()
else:
config = configparser.SafeConfigParser()
# where is the config?
vmware_ini_path = os.environ.get('VMWARE_INI_PATH', defaults['vmware']['ini_path'])
vmware_ini_path = os.path.expanduser(os.path.expandvars(vmware_ini_path))
config.read(vmware_ini_path)
if 'vmware' not in config.sections():
config.add_section('vmware')
# apply defaults
for k, v in defaults['vmware'].items():
if not config.has_option('vmware', k):
config.set('vmware', k, str(v))
# where is the cache?
self.cache_dir = os.path.expanduser(config.get('vmware', 'cache_path'))
if self.cache_dir and not os.path.exists(self.cache_dir):
os.makedirs(self.cache_dir)
# set the cache filename and max age
cache_name = config.get('vmware', 'cache_name')
self.cache_path_cache = self.cache_dir + "/%s.cache" % cache_name
self.debugl('cache path is %s' % self.cache_path_cache)
self.cache_max_age = int(config.getint('vmware', 'cache_max_age'))
# mark the connection info
self.server = os.environ.get('VMWARE_SERVER', config.get('vmware', 'server'))
self.debugl('server is %s' % self.server)
self.port = int(os.environ.get('VMWARE_PORT', config.get('vmware', 'port')))
self.username = os.environ.get('VMWARE_USERNAME', config.get('vmware', 'username'))
self.debugl('username is %s' % self.username)
self.password = os.environ.get('VMWARE_PASSWORD', config.get('vmware', 'password', raw=True))
self.validate_certs = os.environ.get('VMWARE_VALIDATE_CERTS', config.get('vmware', 'validate_certs'))
if self.validate_certs in ['no', 'false', 'False', False]:
self.validate_certs = False
self.debugl('cert validation is %s' % self.validate_certs)
# behavior control
self.maxlevel = int(config.get('vmware', 'max_object_level'))
self.debugl('max object level is %s' % self.maxlevel)
self.lowerkeys = config.get('vmware', 'lower_var_keys')
if type(self.lowerkeys) != bool:
if str(self.lowerkeys).lower() in ['yes', 'true', '1']:
self.lowerkeys = True
else:
self.lowerkeys = False
self.debugl('lower keys is %s' % self.lowerkeys)
self.skip_keys = list(config.get('vmware', 'skip_keys').split(','))
self.debugl('skip keys is %s' % self.skip_keys)
temp_host_filters = list(config.get('vmware', 'host_filters').split('}},'))
for host_filter in temp_host_filters:
host_filter = host_filter.rstrip()
if host_filter != "":
if not host_filter.endswith("}}"):
host_filter += "}}"
self.host_filters.append(host_filter)
self.debugl('host filters are %s' % self.host_filters)
temp_groupby_patterns = list(config.get('vmware', 'groupby_patterns').split('}},'))
for groupby_pattern in temp_groupby_patterns:
groupby_pattern = groupby_pattern.rstrip()
if groupby_pattern != "":
if not groupby_pattern.endswith("}}"):
groupby_pattern += "}}"
self.groupby_patterns.append(groupby_pattern)
self.debugl('groupby patterns are %s' % self.groupby_patterns)
temp_groupby_custom_field_excludes = config.get('vmware', 'groupby_custom_field_excludes')
self.groupby_custom_field_excludes = [x.strip('"') for x in [y.strip("'") for y in temp_groupby_custom_field_excludes.split(",")]]
self.debugl('groupby exclude strings are %s' % self.groupby_custom_field_excludes)
# Special feature to disable the brute force serialization of the
# virtual machine objects. The key name for these properties does not
# matter because the values are just items for a larger list.
if config.has_section('properties'):
self.guest_props = []
for prop in config.items('properties'):
self.guest_props.append(prop[1])
# save the config
self.config = config
def parse_cli_args(self):
''' Command line argument processing '''
parser = argparse.ArgumentParser(description='Produce an Ansible Inventory file based on PyVmomi')
parser.add_argument('--debug', action='store_true', default=False,
help='show debug info')
parser.add_argument('--list', action='store_true', default=True,
help='List instances (default: True)')
parser.add_argument('--host', action='store',
help='Get all the variables about a specific instance')
parser.add_argument('--refresh-cache', action='store_true', default=False,
help='Force refresh of cache by making API requests to VSphere (default: False - use cache files)')
parser.add_argument('--max-instances', default=None, type=int,
help='maximum number of instances to retrieve')
self.args = parser.parse_args()
def get_instances(self):
''' Get a list of vm instances with pyvmomi '''
kwargs = {'host': self.server,
'user': self.username,
'pwd': self.password,
'port': int(self.port)}
if self.validate_certs and hasattr(ssl, 'SSLContext'):
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.verify_mode = ssl.CERT_REQUIRED
context.check_hostname = True
kwargs['sslContext'] = context
elif self.validate_certs and not hasattr(ssl, 'SSLContext'):
sys.exit('pyVim does not support changing verification mode with python < 2.7.9. Either update '
'python or use validate_certs=false.')
elif not self.validate_certs and hasattr(ssl, 'SSLContext'):
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.verify_mode = ssl.CERT_NONE
context.check_hostname = False
kwargs['sslContext'] = context
elif not self.validate_certs and not hasattr(ssl, 'SSLContext'):
# Python 2.7.9 < or RHEL/CentOS 7.4 <
pass
return self._get_instances(kwargs)
def _get_instances(self, inkwargs):
''' Make API calls '''
instances = []
si = None
try:
si = SmartConnect(**inkwargs)
except ssl.SSLError as connection_error:
if '[SSL: CERTIFICATE_VERIFY_FAILED]' in str(connection_error) and self.validate_certs:
sys.exit("Unable to connect to ESXi server due to %s, "
"please specify validate_certs=False and try again" % connection_error)
except Exception as exc:
self.debugl("Unable to connect to ESXi server due to %s" % exc)
sys.exit("Unable to connect to ESXi server due to %s" % exc)
self.debugl('retrieving all instances')
if not si:
sys.exit("Could not connect to the specified host using specified "
"username and password")
atexit.register(Disconnect, si)
content = si.RetrieveContent()
# Create a search container for virtualmachines
self.debugl('creating containerview for virtualmachines')
container = content.rootFolder
viewType = [vim.VirtualMachine]
recursive = True
containerView = content.viewManager.CreateContainerView(container, viewType, recursive)
children = containerView.view
for child in children:
# If requested, limit the total number of instances
if self.args.max_instances:
if len(instances) >= self.args.max_instances:
break
instances.append(child)
self.debugl("%s total instances in container view" % len(instances))
if self.args.host:
instances = [x for x in instances if x.name == self.args.host]
instance_tuples = []
for instance in instances:
if self.guest_props:
ifacts = self.facts_from_proplist(instance)
else:
ifacts = self.facts_from_vobj(instance)
instance_tuples.append((instance, ifacts))
self.debugl('facts collected for all instances')
try:
cfm = content.customFieldsManager
if cfm is not None and cfm.field:
for f in cfm.field:
if not f.managedObjectType or f.managedObjectType == vim.VirtualMachine:
self.custom_fields[f.key] = f.name
self.debugl('%d custom fields collected' % len(self.custom_fields))
except vmodl.RuntimeFault as exc:
self.debugl("Unable to gather custom fields due to %s" % exc.msg)
except IndexError as exc:
self.debugl("Unable to gather custom fields due to %s" % exc)
return instance_tuples
def instances_to_inventory(self, instances):
''' Convert a list of vm objects into a json compliant inventory '''
self.debugl('re-indexing instances based on ini settings')
inventory = VMWareInventory._empty_inventory()
inventory['all'] = {}
inventory['all']['hosts'] = []
for idx, instance in enumerate(instances):
# make a unique id for this object to avoid vmware's
# numerous uuid's which aren't all unique.
thisid = str(uuid.uuid4())
idata = instance[1]
# Put it in the inventory
inventory['all']['hosts'].append(thisid)
inventory['_meta']['hostvars'][thisid] = idata.copy()
inventory['_meta']['hostvars'][thisid]['ansible_uuid'] = thisid
# Make a map of the uuid to the alias the user wants
name_mapping = self.create_template_mapping(
inventory,
self.config.get('vmware', 'alias_pattern')
)
# Make a map of the uuid to the ssh hostname the user wants
host_mapping = self.create_template_mapping(
inventory,
self.config.get('vmware', 'host_pattern')
)
# Reset the inventory keys
for k, v in name_mapping.items():
if not host_mapping or k not in host_mapping:
continue
# set ansible_host (2.x)
try:
inventory['_meta']['hostvars'][k]['ansible_host'] = host_mapping[k]
# 1.9.x backwards compliance
inventory['_meta']['hostvars'][k]['ansible_ssh_host'] = host_mapping[k]
except Exception:
continue
if k == v:
continue
# add new key
inventory['all']['hosts'].append(v)
inventory['_meta']['hostvars'][v] = inventory['_meta']['hostvars'][k]
# cleanup old key
inventory['all']['hosts'].remove(k)
inventory['_meta']['hostvars'].pop(k, None)
self.debugl('pre-filtered hosts:')
for i in inventory['all']['hosts']:
self.debugl(' * %s' % i)
# Apply host filters
for hf in self.host_filters:
if not hf:
continue
self.debugl('filter: %s' % hf)
filter_map = self.create_template_mapping(inventory, hf, dtype='boolean')
for k, v in filter_map.items():
if not v:
# delete this host
inventory['all']['hosts'].remove(k)
inventory['_meta']['hostvars'].pop(k, None)
self.debugl('post-filter hosts:')
for i in inventory['all']['hosts']:
self.debugl(' * %s' % i)
# Create groups
for gbp in self.groupby_patterns:
groupby_map = self.create_template_mapping(inventory, gbp)
for k, v in groupby_map.items():
if v not in inventory:
inventory[v] = {}
inventory[v]['hosts'] = []
if k not in inventory[v]['hosts']:
inventory[v]['hosts'].append(k)
if self.config.get('vmware', 'groupby_custom_field'):
for k, v in inventory['_meta']['hostvars'].items():
if 'customvalue' in v:
for tv in v['customvalue']:
newkey = None
field_name = self.custom_fields[tv['key']] if tv['key'] in self.custom_fields else tv['key']
if field_name in self.groupby_custom_field_excludes:
continue
values = []
keylist = map(lambda x: x.strip(), tv['value'].split(','))
for kl in keylist:
try:
newkey = "%s%s_%s" % (self.config.get('vmware', 'custom_field_group_prefix'), str(field_name), kl)
newkey = newkey.strip()
except Exception as e:
self.debugl(e)
values.append(newkey)
for tag in values:
if not tag:
continue
if tag not in inventory:
inventory[tag] = {}
inventory[tag]['hosts'] = []
if k not in inventory[tag]['hosts']:
inventory[tag]['hosts'].append(k)
return inventory
def create_template_mapping(self, inventory, pattern, dtype='string'):
''' Return a hash of uuid to templated string from pattern '''
mapping = {}
for k, v in inventory['_meta']['hostvars'].items():
t = self.env.from_string(pattern)
newkey = None
try:
newkey = t.render(v)
newkey = newkey.strip()
except Exception as e:
self.debugl(e)
if not newkey:
continue
elif dtype == 'integer':
newkey = int(newkey)
elif dtype == 'boolean':
if newkey.lower() == 'false':
newkey = False
elif newkey.lower() == 'true':
newkey = True
elif dtype == 'string':
pass
mapping[k] = newkey
return mapping
def facts_from_proplist(self, vm):
'''Get specific properties instead of serializing everything'''
rdata = {}
for prop in self.guest_props:
self.debugl('getting %s property for %s' % (prop, vm.name))
key = prop
if self.lowerkeys:
key = key.lower()
if '.' not in prop:
# props without periods are direct attributes of the parent
vm_property = getattr(vm, prop)
if isinstance(vm_property, vim.CustomFieldsManager.Value.Array):
temp_vm_property = []
for vm_prop in vm_property:
temp_vm_property.append({'key': vm_prop.key,
'value': vm_prop.value})
rdata[key] = temp_vm_property
else:
rdata[key] = vm_property
else:
# props with periods are subkeys of parent attributes
parts = prop.split('.')
total = len(parts) - 1
# pointer to the current object
val = None
# pointer to the current result key
lastref = rdata
for idx, x in enumerate(parts):
if isinstance(val, dict):
if x in val:
val = val.get(x)
elif x.lower() in val:
val = val.get(x.lower())
else:
# if the val wasn't set yet, get it from the parent
if not val:
try:
val = getattr(vm, x)
except AttributeError as e:
self.debugl(e)
else:
# in a subkey, get the subprop from the previous attrib
try:
val = getattr(val, x)
except AttributeError as e:
self.debugl(e)
# make sure it serializes
val = self._process_object_types(val)
# lowercase keys if requested
if self.lowerkeys:
x = x.lower()
# change the pointer or set the final value
if idx != total:
if x not in lastref:
lastref[x] = {}
lastref = lastref[x]
else:
lastref[x] = val
if self.args.debug:
self.debugl("For %s" % vm.name)
for key in list(rdata.keys()):
if isinstance(rdata[key], dict):
for ikey in list(rdata[key].keys()):
self.debugl("Property '%s.%s' has value '%s'" % (key, ikey, rdata[key][ikey]))
else:
self.debugl("Property '%s' has value '%s'" % (key, rdata[key]))
return rdata
def facts_from_vobj(self, vobj, level=0):
''' Traverse a VM object and return a json compliant data structure '''
# pyvmomi objects are not yet serializable, but may be one day ...
# https://github.com/vmware/pyvmomi/issues/21
# WARNING:
# Accessing an object attribute will trigger a SOAP call to the remote.
# Increasing the attributes collected or the depth of recursion greatly
# increases runtime duration and potentially memory+network utilization.
if level == 0:
try:
self.debugl("get facts for %s" % vobj.name)
except Exception as e:
self.debugl(e)
rdata = {}
methods = dir(vobj)
methods = [str(x) for x in methods if not x.startswith('_')]
methods = [x for x in methods if x not in self.bad_types]
methods = [x for x in methods if not x.lower() in self.skip_keys]
methods = sorted(methods)
for method in methods:
# Attempt to get the method, skip on fail
try:
methodToCall = getattr(vobj, method)
except Exception as e:
continue
# Skip callable methods
if callable(methodToCall):
continue
if self.lowerkeys:
method = method.lower()
rdata[method] = self._process_object_types(
methodToCall,
thisvm=vobj,
inkey=method,
)
return rdata
def _process_object_types(self, vobj, thisvm=None, inkey='', level=0):
''' Serialize an object '''
rdata = {}
if type(vobj).__name__ in self.vimTableMaxDepth and level >= self.vimTableMaxDepth[type(vobj).__name__]:
return rdata
if vobj is None:
rdata = None
elif type(vobj) in self.vimTable:
rdata = {}
for key in self.vimTable[type(vobj)]:
try:
rdata[key] = getattr(vobj, key)
except Exception as e:
self.debugl(e)
elif issubclass(type(vobj), str) or isinstance(vobj, str):
if vobj.isalnum():
rdata = vobj
else:
rdata = vobj.encode('utf-8').decode('utf-8')
elif issubclass(type(vobj), bool) or isinstance(vobj, bool):
rdata = vobj
elif issubclass(type(vobj), integer_types) or isinstance(vobj, integer_types):
rdata = vobj
elif issubclass(type(vobj), float) or isinstance(vobj, float):
rdata = vobj
elif issubclass(type(vobj), list) or issubclass(type(vobj), tuple):
rdata = []
try:
vobj = sorted(vobj)
except Exception:
pass
for idv, vii in enumerate(vobj):
if level + 1 <= self.maxlevel:
vid = self._process_object_types(
vii,
thisvm=thisvm,
inkey=inkey + '[' + str(idv) + ']',
level=(level + 1)
)
if vid:
rdata.append(vid)
elif issubclass(type(vobj), dict):
pass
elif issubclass(type(vobj), object):
methods = dir(vobj)
methods = [str(x) for x in methods if not x.startswith('_')]
methods = [x for x in methods if x not in self.bad_types]
methods = [x for x in methods if not inkey + '.' + x.lower() in self.skip_keys]
methods = sorted(methods)
for method in methods:
# Attempt to get the method, skip on fail
try:
methodToCall = getattr(vobj, method)
except Exception as e:
continue
if callable(methodToCall):
continue
if self.lowerkeys:
method = method.lower()
if level + 1 <= self.maxlevel:
try:
rdata[method] = self._process_object_types(
methodToCall,
thisvm=thisvm,
inkey=inkey + '.' + method,
level=(level + 1)
)
except vim.fault.NoPermission:
self.debugl("Skipping method %s (NoPermission)" % method)
else:
pass
return rdata
def get_host_info(self, host):
''' Return hostvars for a single host '''
if host in self.inventory['_meta']['hostvars']:
return self.inventory['_meta']['hostvars'][host]
elif self.args.host and self.inventory['_meta']['hostvars']:
match = None
for k, v in self.inventory['_meta']['hostvars'].items():
if self.inventory['_meta']['hostvars'][k]['name'] == self.args.host:
match = k
break
if match:
return self.inventory['_meta']['hostvars'][match]
else:
raise VMwareMissingHostException('%s not found' % host)
else:
raise VMwareMissingHostException('%s not found' % host)
if __name__ == "__main__":
# Run the script
print(VMWareInventory().show())

3
test/integration/targets/incidental_script_inventory_vmware_inventory/vmware_inventory.sh
View file

@ -1,3 +0,0 @@
#!/usr/bin/env bash
python.py "./vmware_inventory.py" "$@"

3
test/integration/targets/incidental_vmware_guest/aliases
View file

@ -1,3 +0,0 @@
shippable/vcenter/incidental
cloud/vcenter
needs/target/incidental_vmware_prepare_tests

33
test/integration/targets/incidental_vmware_guest/defaults/main.yml
View file

@ -1,33 +0,0 @@
vmware_guest_test_playbooks:
- boot_firmware_d1_c1_f0.yml
- boot_firmware_d1_c1_f0.yml
- cdrom_d1_c1_f0.yml
- check_mode.yml
- clone_customize_guest_test.yml
- clone_d1_c1_f0.yml
- clone_resize_disks.yml
- clone_with_convert.yml
- create_d1_c1_f0.yml
- create_guest_invalid_d1_c1_f0.yml
- create_nw_d1_c1_f0.yml
- create_rp_d1_c1_f0.yml
- delete_vm.yml
- disk_mode_d1_c1_f0.yml
- disk_size_d1_c1_f0.yml
- disk_type_d1_c1_f0.yml
- linked_clone_d1_c1_f0.yml
- mac_address_d1_c1_f0.yml
- max_connections.yml
- mem_reservation.yml
- network_negative_test.yml
- network_with_device.yml
# Currently, VCSIM doesn't support DVPG (as portkeys are not available) so commenting this test
# - network_with_dvpg.yml
# - network_with_portgroup.yml
- non_existent_vm_ops.yml
- poweroff_d1_c1_f0.yml
- poweroff_d1_c1_f1.yml
# - template_d1_c1_f0.yml
- vapp_d1_c1_f0.yml
- reconfig_vm_to_latest_version.yml
- remove_vm_from_inventory.yml

117
test/integration/targets/incidental_vmware_guest/tasks/boot_firmware_d1_c1_f0.yml
View file

@ -1,117 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2018, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: create new VMs with boot_firmware as 'bios'
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
boot_firmware: "bios"
memory_mb: 128
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: poweredoff
folder: "{{ f0 }}"
register: clone_d1_c1_f0
- debug: var=clone_d1_c1_f0
- name: assert that changes were made
assert:
that:
- clone_d1_c1_f0 is changed
# VCSIM does not recognizes existing VMs boot firmware
- when: vcsim is not defined
block:
- name: create new VMs again with boot_firmware as 'bios'
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm2
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
boot_firmware: "bios"
memory_mb: 128
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: poweredoff
folder: "{{ f0 }}"
register: clone_d1_c1_f0
- debug: var=clone_d1_c1_f0
- name: assert that changes were not made
assert:
that:
- clone_d1_c1_f0 is changed
- name: create new VMs with boot_firmware as 'efi'
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm3
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
boot_firmware: "efi"
memory_mb: 128
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: poweredoff
folder: "{{ f0 }}"
register: clone_d1_c1_f0
- debug: var=clone_d1_c1_f0
- name: assert that changes were made
assert:
that:
- clone_d1_c1_f0 is changed
# VCSIM does not recognizes existing VMs boot firmware
- when: vcsim is not defined
block:
- name: create new VMs again with boot_firmware as 'efi'
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm3
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
boot_firmware: "efi"
memory_mb: 128
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: poweredoff
folder: "{{ f0 }}"
register: clone_d1_c1_f0
- debug: var=clone_d1_c1_f0
- name: assert that changes were not made
assert:
that:
- not (clone_d1_c1_f0 is changed)

269
test/integration/targets/incidental_vmware_guest/tasks/cdrom_d1_c1_f0.yml
View file

@ -1,269 +0,0 @@
- name: Create VM with CDROM
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
folder: vm
name: test_vm1
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
resource_pool: Resources
guest_id: centos64Guest
hardware:
memory_mb: 128
num_cpus: 1
scsi: paravirtual
disk:
- size_mb: 128
type: thin
datastore: "{{ rw_datastore }}"
cdrom:
type: iso
iso_path: "[{{ ro_datastore }}] centos.iso"
register: cdrom_vm
- debug: var=cdrom_vm
- name: assert the VM was created
assert:
that:
- "cdrom_vm.changed == true"
- name: Update CDROM to iso for the new VM
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
folder: "vm"
name: test_vm1
datastore: "{{ rw_datastore }}"
datacenter: "{{ dc1 }}"
cdrom:
type: iso
iso_path: "[{{ ro_datastore }}] fedora.iso"
state: present
register: cdrom_vm
- debug: var=cdrom_vm
- name: assert the VM was changed
assert:
that:
- "cdrom_vm.changed == true"
- name: Update CDROM to client for the new VM
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
folder: vm
name: test_vm1
datacenter: "{{ dc1 }}"
cdrom:
type: client
state: present
register: cdrom_vm
- debug: var=cdrom_vm
- name: assert the VM was changed
assert:
that:
- "cdrom_vm.changed == true"
- name: clone vm
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm2
template: test_vm1
datacenter: "{{ dc1 }}"
state: poweredoff
folder: vm
convert: thin
- name: Update CDROM to none for the new VM
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
folder: vm
name: test_vm2
datacenter: "{{ dc1 }}"
cdrom:
type: none
state: present
register: cdrom_vm
- debug: var=cdrom_vm
- name: assert the VM was changed
assert:
that:
- "cdrom_vm.changed == true"
- name: Create VM with multiple disks and a CDROM - GitHub issue 38679
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
folder: "{{ f0 }}"
name: test_vm3
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
resource_pool: Resources
guest_id: centos64Guest
hardware:
memory_mb: 128
num_cpus: 1
scsi: paravirtual
disk:
- size_mb: 128
type: thin
datastore: "{{ rw_datastore }}"
- size_mb: 128
type: thin
datastore: "{{ rw_datastore }}"
- size_mb: 128
type: thin
datastore: "{{ rw_datastore }}"
cdrom:
type: iso
iso_path: "[{{ ro_datastore }}] fedora.iso"
register: cdrom_vm
- debug: var=cdrom_vm
- name: assert the VM was created
assert:
that:
- "cdrom_vm.changed == true"
- name: Create VM with multiple CDROMs
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
folder: vm
name: test_vm1
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
resource_pool: Resources
guest_id: centos64Guest
hardware:
memory_mb: 128
num_cpus: 1
scsi: paravirtual
disk:
- size_mb: 128
type: thin
datastore: "{{ rw_datastore }}"
cdrom:
- controller_type: ide
controller_number: 0
unit_number: 0
type: iso
iso_path: "[{{ ro_datastore }}] centos.iso"
- controller_type: ide
controller_number: 0
unit_number: 1
type: client
- controller_number: 1
unit_number: 0
type: none
- controller_number: 1
unit_number: 1
type: client
register: cdrom_vm
- debug: var=cdrom_vm
- name: assert the VM was created
assert:
that:
- "cdrom_vm.changed == true"
- name: Remove the last 2 CDROMs and update the first 2 for the new VM
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
folder: vm
name: test_vm1
datacenter: "{{ dc1 }}"
cdrom:
- controller_type: ide
controller_number: 0
unit_number: 0
type: client
- controller_type: ide
controller_number: 0
unit_number: 1
type: iso
iso_path: "[{{ ro_datastore }}] fedora.iso"
- controller_type: ide
controller_number: 1
unit_number: 0
state: absent
- controller_type: ide
controller_number: 1
unit_number: 1
state: absent
state: present
register: cdrom_vm
- debug: var=cdrom_vm
- name: assert the VM was changed
assert:
that:
- "cdrom_vm.changed == true"
# VCSIM fails with invalidspec exception but real vCenter PASS testcase
# Commenting this testcase till the time
- when: vcsim is not defined
block:
- name: Again create VM with multiple disks and a CDROM - GitHub issue 38679
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
folder: "{{ f0 }}"
name: test_vm3
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
resource_pool: Resources
guest_id: centos64Guest
hardware:
memory_mb: 128
num_cpus: 1
scsi: paravirtual
disk:
- size_mb: 128
type: thin
datastore: "{{ rw_datastore }}"
- size_mb: 128
type: thin
datastore: "{{ rw_datastore }}"
- size_mb: 128
type: thin
datastore: "{{ rw_datastore }}"
cdrom:
type: iso
iso_path: "[{{ ro_datastore }}] base.iso"
register: cdrom_vm
- debug: var=cdrom_vm
- name: assert the VM was created
assert:
that:
- cdrom_vm is changed

60
test/integration/targets/incidental_vmware_guest/tasks/check_mode.yml
View file

@ -1,60 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2018, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: Perform all operation in check mode
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: "{{ virtual_machines[0].name }}"
datacenter: "{{ dc1 }}"
state: "{{ item }}"
with_items:
- absent
- present
- poweredoff
- poweredon
- restarted
- suspended
- shutdownguest
- rebootguest
register: check_mode_state
check_mode: yes
- debug:
var: check_mode_state
- name: assert that changes were made
assert:
that:
- "check_mode_state.results|map(attribute='changed')|unique|list == [true]"
- "check_mode_state.results|map(attribute='vm_name')|unique|list == [ virtual_machines[0].name ]"
- name: Perform all operation on non-existent VM in check mode
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: non_existent_vm
datacenter: "{{ dc1 }}"
state: "{{ item }}"
with_items:
- present
- poweredoff
- poweredon
- restarted
- suspended
register: check_mode_state
check_mode: yes
- debug:
var: check_mode_state
- name: assert that changes were made
assert:
that:
- "check_mode_state.results|map(attribute='changed')|unique|list == [true]"
- "check_mode_state.results|map(attribute='desired_operation')|unique|list == ['deploy_vm']"

47
test/integration/targets/incidental_vmware_guest/tasks/clone_customize_guest_test.yml
View file

@ -1,47 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2019, Pavan Bidkar <pbidkar@vmware.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: clone vm from template and customize GOS
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
template: "{{ virtual_machines[0].name }}"
datacenter: "{{ dc1 }}"
state: poweredoff
folder: "{{ virtual_machines[0].folder }}"
convert: thin
register: clone_customize
- debug:
var: clone_customize
- name: assert that changes were made
assert:
that:
- clone_customize is changed
- name: clone vm from template and customize GOS again
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
template: "{{ virtual_machines[0].name }}"
datacenter: "{{ dc1 }}"
state: poweredoff
folder: "{{ virtual_machines[0].folder }}"
convert: thin
register: clone_customize_again
- debug:
var: clone_customize_again
- name: assert that changes were not made
assert:
that:
- not (clone_customize_again is changed)

101
test/integration/targets/incidental_vmware_guest/tasks/clone_d1_c1_f0.yml
View file

@ -1,101 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2017, James Tanner <tanner.jc@gmail.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: create new linked clone without specifying snapshot_src
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
template: "{{ virtual_machines[0].name }}"
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
folder: "{{ f0 }}"
linked_clone: True
register: linked_clone_d1_c1_f0
ignore_errors: True
- debug:
var: linked_clone_d1_c1_f0
- name: assert that changes were not made
assert:
that:
- not (linked_clone_d1_c1_f0 is changed)
- name: create new linked clone without specifying linked_clone
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm2
template: "{{ virtual_machines[0].name }}"
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
folder: "{{ f0 }}"
snapshot_src: "snap_shot1"
register: linked_clone_d1_c1_f0
ignore_errors: True
- debug:
var: linked_clone_d1_c1_f0
- name: assert that changes were not made
assert:
that:
- not (linked_clone_d1_c1_f0 is changed)
# TODO: VCSIM: snapshot is not supported in current vcsim
#
#- name: create new linked clone with linked_clone and snapshot_src
# vmware_guest:
# validate_certs: False
# hostname: "{{ vcenter_hostname }}"
# username: "{{ vcenter_username }}"
# password: "{{ vcenter_password }}"
# name: "{{ 'new_vm_' + item|basename }}"
# template: "{{ item|basename }}"
# guest_id: centos64Guest
# datacenter: "{{ (item|basename).split('_')[0] }}"
# folder: "{{ item|dirname }}"
# snapshot_src: "snap_shot1"
# linked_clone: True
# with_items: "{{ vmlist['json'] }}"
# register: linked_clone_d1_c1_f0
# ignore_errors: True
#- debug: var=linked_clone_d1_c1_f0
#- name: assert that changes were made
# assert:
# that:
# - "linked_clone_d1_c1_f0.results|map(attribute='changed')|unique|list == [true]"
# TODO: VCSIM: snapshot is not supported in current vcsim
#
#- name: create new linked clone with linked_clone and snapshot_src again
# vmware_guest:
# validate_certs: False
# hostname: "{{ vcenter_hostname }}"
# username: "{{ vcenter_username }}"
# password: "{{ vcenter_password }}"
# name: "{{ 'new_vm_' + item|basename }}"
# template: "{{ item|basename }}"
# guest_id: centos64Guest
# datacenter: "{{ (item|basename).split('_')[0] }}"
# folder: "{{ item|dirname }}"
# snapshot_src: "snap_shot1"
# linked_clone: True
# with_items: "{{ vmlist['json'] }}"
# register: linked_clone_d1_c1_f0
# ignore_errors: True
#- debug: var=linked_clone_d1_c1_f0
#- name: assert that changes were not made
# assert:
# that:
# - "linked_clone_d1_c1_f0.results|map(attribute='changed')|unique|list == [false]"

77
test/integration/targets/incidental_vmware_guest/tasks/clone_resize_disks.yml
View file

@ -1,77 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2019, Noe Gonzalez <noe.a.gonzalez@gmail.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- when: vcsim is not defined
block:
- name: create new VM
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: clone_resize_disks_original
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
folder: "{{ f0 }}"
hardware:
num_cpus: 1
memory_mb: 128
guest_id: centos7_64Guest
disk:
- size_gb: 1
type: thin
datastore: "{{ rw_datastore }}"
state: poweredoff
- name: convert to VM template
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: clone_resize_disks_original
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
folder: "{{ f0 }}"
is_template: True
- name: clone template and modify disks
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: clone_resize_disks_clone
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
folder: "{{ f0 }}"
disk:
- size_gb: 2
type: thin
datastore: "{{ rw_datastore }}"
- size_gb: 3
type: thin
datastore: "{{ rw_datastore }}"
template: clone_resize_disks_original
state: poweredoff
register: l_clone_template_modify_disks
- assert:
that:
- l_clone_template_modify_disks.changed | bool
- name: delete VM clone & original template
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: "{{ item }}"
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
folder: "{{ f0 }}"
state: absent
with_items:
- clone_resize_disks_original
- clone_resize_disks_clone

66
test/integration/targets/incidental_vmware_guest/tasks/clone_with_convert.yml
View file

@ -1,66 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2018, Christophe FERREIRA <christophe.ferreira@cnaf.fr>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: clone vm from template and convert to thin
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
template: "{{ virtual_machines[0].name }}"
datacenter: "{{ dc1 }}"
state: poweredoff
folder: "{{ virtual_machines[0].folder }}"
convert: thin
register: clone_thin
- debug: var=clone_thin
- name: assert that changes were made
assert:
that:
- clone_thin is changed
- name: clone vm from template and convert to thick
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm2
template: "{{ virtual_machines[0].name }}"
datacenter: "{{ dc1 }}"
state: poweredoff
folder: "{{ virtual_machines[0].folder }}"
convert: thick
register: clone_thick
- debug: var=clone_thick
- name: assert that changes were made
assert:
that:
- clone_thick is changed
- name: clone vm from template and convert to eagerzeroedthick
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm3
template: "{{ virtual_machines[0].name }}"
datacenter: "{{ dc1 }}"
state: poweredoff
folder: "{{ virtual_machines[0].folder }}"
convert: eagerzeroedthick
register: clone_eagerzeroedthick
- debug: var=clone_eagerzeroedthick
- name: assert that changes were made
assert:
that:
- clone_eagerzeroedthick is changed

164
test/integration/targets/incidental_vmware_guest/tasks/create_d1_c1_f0.yml
View file

@ -1,164 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2017, James Tanner <tanner.jc@gmail.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: create new VMs
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
#template: "{{ item|basename }}"
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
num_cpu_cores_per_socket: 1
memory_mb: 128
hotadd_memory: true
hotadd_cpu: false
# vcsim does not support these settings, so commenting
# till the time.
# memory_reservation: 128
# memory_reservation_lock: False
# nested_virt: True
# hotremove_cpu: True
# mem_limit: 8096
# mem_reservation: 4096
# cpu_limit: 8096
# cpu_reservation: 4096
max_connections: 10
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: poweredoff
folder: '{{ f0 }}'
register: clone_d1_c1_f0
- debug: var=clone_d1_c1_f0
- name: assert that changes were made
assert:
that:
- clone_d1_c1_f0 is changed
- name: create the VM again
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
#template: "{{ item|basename }}"
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
num_cpu_cores_per_socket: 1
memory_mb: 128
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: poweredoff
folder: '{{ f0 }}'
register: clone_d1_c1_f0_recreate
- debug: var=clone_d1_c1_f0_recreate
- name: assert that no changes were made after re-creating
assert:
that:
- not (clone_d1_c1_f0_recreate is changed)
- name: modify the new VMs
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
#template: "{{ item|basename }}"
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 2
memory_mb: 128
state: present
folder: '{{ f0 }}'
register: clone_d1_c1_f0_modify
- debug: var=clone_d1_c1_f0_modify
- name: assert that changes were made with modification
assert:
that:
- clone_d1_c1_f0_modify is changed
- name: re-modify the new VMs
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
#template: "{{ item|basename }}"
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 2
memory_mb: 128
state: present
folder: '{{ f0 }}'
register: clone_d1_c1_f0_remodify
- debug: var=clone_d1_c1_f0_remodify
- name: assert that no changes were made when re-modified
assert:
that:
- not (clone_d1_c1_f0_remodify is changed)
- name: delete the new VMs
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
#template: "{{ item|basename }}"
#guest_id: centos64Guest
datacenter: "{{ dc1 }}"
state: absent
folder: '{{ f0 }}'
register: clone_d1_c1_f0_delete
- debug: var=clone_d1_c1_f0_delete
- name: assert that changes were made with deletion
assert:
that:
- clone_d1_c1_f0_delete is changed
- name: re-delete the new VMs
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
#template: "{{ item|basename }}"
#guest_id: centos64Guest
datacenter: "{{ dc1 }}"
state: absent
folder: '{{ f0 }}'
register: clone_d1_c1_f0_redelete
- debug: var=clone_d1_c1_f0_redelete
- name: assert that no changes were made with redeletion
assert:
that:
- not (clone_d1_c1_f0_redelete is changed)

32
test/integration/targets/incidental_vmware_guest/tasks/create_guest_invalid_d1_c1_f0.yml
View file

@ -1,32 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2017, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- when: vcsim is not defined
block:
- name: create new virtual machine with invalid guest id
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: invalid_vm
guest_id: "invalid_guest_id"
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
memory_mb: 128
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: present
folder: "{{ f0 }}"
register: invalid_guest_0001_d1_c1_f0
ignore_errors: yes
- debug: var=invalid_guest_0001_d1_c1_f0
- name: assert that changes were made
assert:
that:
- "not (invalid_guest_0001_d1_c1_f0 is changed)"
- "'configSpec.guestId' in invalid_guest_0001_d1_c1_f0['msg']"

38
test/integration/targets/incidental_vmware_guest/tasks/create_nw_d1_c1_f0.yml
View file

@ -1,38 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2017, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: create new VMs
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
memory_mb: 128
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
networks:
- name: 'VM Network'
device_type: vmxnet3
ip: 192.168.10.1
netmask: 255.255.255.0
wake_on_lan: True
start_connected: True
allow_guest_control: True
state: poweredoff
folder: F0
register: clone_d1_c1_f0
- debug: var=clone_d1_c1_f0
- name: assert that changes were made
assert:
that:
- clone_d1_c1_f0 is changed

205
test/integration/targets/incidental_vmware_guest/tasks/create_rp_d1_c1_f0.yml
View file

@ -1,205 +0,0 @@
# Create one with the defaults
- name: create new VM with default resource pool
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
#template: "{{ item|basename }}"
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
memory_mb: 128
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: poweredoff
folder: F0
register: clone_rp_d1_c1_f0
- debug: var=clone_rp_d1_c1_f0
- name: assert that changes were made
assert:
that:
- clone_rp_d1_c1_f0 is changed
- name: delete the new VMs
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
#template: "{{ item|basename }}"
#guest_id: centos64Guest
datacenter: "{{ dc1 }}"
state: absent
folder: F0
register: clone_rp_d1_c1_f0_delete
- debug: var=clone_rp_d1_c1_f0_delete
- name: assert that changes were made with deletion
assert:
that:
- clone_rp_d1_c1_f0_delete is changed
# now create with just a cluster
- name: create new VM with default resource pool in cluster
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
#template: "{{ item|basename }}"
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
hardware:
num_cpus: 1
memory_mb: 128
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: poweredoff
folder: F0
register: clone_rpc_d1_c1_f0
- debug: var=clone_rpc_d1_c1_f0
- name: assert that changes were made
assert:
that:
- clone_rpc_d1_c1_f0 is changed
- name: delete the new VMs
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
#template: "{{ item|basename }}"
#guest_id: centos64Guest
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
state: absent
folder: F0
register: clone_rpc_d1_c1_f0_delete
- debug: var=clone_rpc_d1_c1_f0_delete
- name: assert that changes were made with deletion
assert:
that:
- clone_rpc_d1_c1_f0_delete is changed
# now create with a specific resource pool
- name: create new VM with specific resource pool in cluster
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
#template: "{{ item|basename }}"
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
resource_pool: DC0_C0_RP1
hardware:
num_cpus: 1
memory_mb: 128
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: poweredoff
folder: F0
register: clone_rpcp_d1_c1_f0
- debug: var=clone_rpcp_d1_c1_f0
- name: assert that changes were made
assert:
that:
- clone_rpcp_d1_c1_f0 is changed
- name: delete the new VMs
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
#template: "{{ item|basename }}"
#guest_id: centos64Guest
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
state: absent
folder: F0
register: clone_rpcp_d1_c1_f0_delete
- debug: var=clone_rpcp_d1_c1_f0_delete
- name: assert that changes were made with deletion
assert:
that:
- clone_rpcp_d1_c1_f0_delete is changed
# now create with a specific host
- name: create new VM with specific host
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
#template: "{{ item|basename }}"
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
esxi_hostname: '{{ esxi1 }}'
hardware:
num_cpus: 1
memory_mb: 128
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: poweredoff
folder: F0
register: clone_rph_d1_c1_f0
- debug: var=clone_rph_d1_c1_f0
- name: assert that changes were made
assert:
that:
- clone_rph_d1_c1_f0 is changed
- name: delete the new VMs
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
#template: "{{ item|basename }}"
#guest_id: centos64Guest
datacenter: "{{ dc1 }}"
state: absent
folder: F0
register: clone_rph_d1_c1_f0_delete
- debug: var=clone_rph_d1_c1_f0_delete
- name: assert that changes were made with deletion
assert:
that:
- clone_rph_d1_c1_f0_delete is changed

22
test/integration/targets/incidental_vmware_guest/tasks/delete_vm.yml
View file

@ -1,22 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2018, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: Delete VM
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: nothinghere
datacenter: "{{ dc1 }}"
state: absent
register: delete_vm
ignore_errors: yes
- debug: var=delete_vm
- name: assert that changes were made
assert:
that:
- "not delete_vm.changed"

89
test/integration/targets/incidental_vmware_guest/tasks/disk_mode_d1_c1_f0.yml
View file

@ -1,89 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2018, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: create new VMs with invalid disk mode
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
memory_mb: 128
disk:
- size: 1gb
type: eagerzeroedthick
datastore: "{{ rw_datastore }}"
disk_mode: 'invalid_disk_mode'
state: poweredoff
folder: "{{ f0 }}"
register: test_vm1
ignore_errors: True
- debug: var=test_vm1
- name: assert that changes were not made
assert:
that:
- not(test_vm1 is changed)
- name: create new VMs with valid disk mode
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
memory_mb: 128
disk:
- size: 1gb
type: eagerzeroedthick
datastore: "{{ rw_datastore }}"
disk_mode: 'independent_persistent'
state: poweredoff
folder: "{{ f0 }}"
register: test_vm1_2
- debug: var=test_vm1_2
- name: assert that changes were made
assert:
that:
- test_vm1_2 is changed
#TODO: vcsim does not support reconfiguration of disk mode, fails with types.InvalidDeviceSpec
- when: vcsim is not defined
block:
- name: create new VMs with valid disk mode again
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
memory_mb: 128
disk:
- size: 1gb
type: eagerzeroedthick
datastore: "{{ rw_datastore }}"
disk_mode: 'independent_persistent'
state: poweredoff
folder: "{{ f0 }}"
register: test_vm1_2
- debug: var=test_vm1_2
- name: assert that changes were not made
assert:
that:
- not (test_vm1_2 is changed)

31
test/integration/targets/incidental_vmware_guest/tasks/disk_size_d1_c1_f0.yml
View file

@ -1,31 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2018, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: create new VMs with invalid disk size
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
memory_mb: 128
disk:
- size: 0gb
type: eagerzeroedthick
datastore: "{{ rw_datastore }}"
state: poweredoff
folder: "{{ f0 }}"
register: disk_size_d1_c1_f0
ignore_errors: True
- debug: var=disk_size_d1_c1_f0
- name: assert that changes were made
assert:
that:
- not (disk_size_d1_c1_f0 is changed)

33
test/integration/targets/incidental_vmware_guest/tasks/disk_type_d1_c1_f0.yml
View file

@ -1,33 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2017, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: create new VMs
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
memory_mb: 128
disk:
- size: 1gb
type: eagerzeroedthick
datastore: "{{ rw_datastore }}"
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: poweredoff
folder: F0
register: disk_type_d1_c1_f0
- debug: var=disk_type_d1_c1_f0
- name: assert that changes were made
assert:
that:
- disk_type_d1_c1_f0 is changed

100
test/integration/targets/incidental_vmware_guest/tasks/linked_clone_d1_c1_f0.yml
View file

@ -1,100 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2018, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: create new linked clone without specifying snapshot_src
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: "{{ 'new_vm_' + item.name }}"
template: "{{ item.name }}"
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
folder: "{{ f0 }}"
linked_clone: True
with_items: "{{ virtual_machines }}"
register: linked_clone_d1_c1_f0
ignore_errors: True
- debug: var=linked_clone_d1_c1_f0
- name: assert that changes were not made
assert:
that:
- "linked_clone_d1_c1_f0.results|map(attribute='changed')|unique|list == [false]"
- name: create new linked clone without specifying linked_clone
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: "{{ 'new_vm_' + item.name }}"
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
folder: "{{ f0 }}"
snapshot_src: "snap_shot1"
with_items: "{{ virtual_machines }}"
register: linked_clone_d1_c1_f0
ignore_errors: True
- debug: var=linked_clone_d1_c1_f0
- name: assert that changes were not made
assert:
that:
- "linked_clone_d1_c1_f0.results|map(attribute='changed')|unique|list == [false]"
# TODO: VCSIM: snapshot is not supported in current vcsim
#
#- name: create new linked clone with linked_clone and snapshot_src
# vmware_guest:
# validate_certs: False
# hostname: "{{ vcsim }}"
# username: "{{ vcsim_instance['json']['username'] }}"
# password: "{{ vcsim_instance['json']['password'] }}"
# name: "{{ 'new_vm_' + item|basename }}"
# template: "{{ item|basename }}"
# guest_id: centos64Guest
# datacenter: "{{ (item|basename).split('_')[0] }}"
# folder: "{{ item|dirname }}"
# snapshot_src: "snap_shot1"
# linked_clone: True
# with_items: "{{ vmlist['json'] }}"
# register: linked_clone_d1_c1_f0
# ignore_errors: True
#- debug: var=linked_clone_d1_c1_f0
#- name: assert that changes were made
# assert:
# that:
# - "linked_clone_d1_c1_f0.results|map(attribute='changed')|unique|list == [true]"
# TODO: VCSIM: snapshot is not supported in current vcsim
#
#- name: create new linked clone with linked_clone and snapshot_src again
# vmware_guest:
# validate_certs: False
# hostname: "{{ vcsim }}"
# username: "{{ vcsim_instance['json']['username'] }}"
# password: "{{ vcsim_instance['json']['password'] }}"
# name: "{{ 'new_vm_' + item|basename }}"
# template: "{{ item|basename }}"
# guest_id: centos64Guest
# datacenter: "{{ (item|basename).split('_')[0] }}"
# folder: "{{ item|dirname }}"
# snapshot_src: "snap_shot1"
# linked_clone: True
# with_items: "{{ vmlist['json'] }}"
# register: linked_clone_d1_c1_f0
# ignore_errors: True
#- debug: var=linked_clone_d1_c1_f0
#- name: assert that changes were not made
# assert:
# that:
# - "linked_clone_d1_c1_f0.results|map(attribute='changed')|unique|list == [false]"

37
test/integration/targets/incidental_vmware_guest/tasks/mac_address_d1_c1_f0.yml
View file

@ -1,37 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2017, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: create new VMs with manual MAC address
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
memory_mb: 128
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
networks:
- name: VM Network
ip: 192.168.10.12
netmask: 255.255.255.0
gateway: 192.168.10.254
mac: aa:bb:cc:dd:aa:42
state: poweredoff
folder: vm
register: clone_d1_c1_f0
- debug: var=clone_d1_c1_f0
- name: assert that changes were made
assert:
that:
- "clone_d1_c1_f0['instance']['hw_eth0']['addresstype'] == 'manual'"
- "clone_d1_c1_f0['instance']['hw_eth0']['macaddress'] == 'aa:bb:cc:dd:aa:42'"

19
test/integration/targets/incidental_vmware_guest/tasks/main.yml
View file

@ -1,19 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2017, James Tanner <tanner.jc@gmail.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- import_role:
name: incidental_vmware_prepare_tests
vars:
setup_attach_host: true
setup_datacenter: true
setup_datastore: true
setup_dvswitch: true
setup_resource_pool: true
setup_virtualmachines: true
setup_dvs_portgroup: true
- include_tasks: run_test_playbook.yml
with_items: '{{ vmware_guest_test_playbooks }}'
loop_control:
loop_var: test_playbook

45
test/integration/targets/incidental_vmware_guest/tasks/max_connections.yml
View file

@ -1,45 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2019, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- when: vcsim is not defined
block:
- &add_mk_conn
name: Create new VM with max_connections as 4
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
memory_mb: 128
max_connections: 4
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: present
folder: "{{ f0 }}"
register: mk_conn_result_0001
- debug: var=mk_conn_result_0001
- name: Assert that changes were made
assert:
that:
- mk_conn_result_0001 is changed
- <<: *add_mk_conn
name: Again create new VMs again with max_connections as 4
register: mk_conn_result_0002
- debug: var=mk_conn_result_0002
- name: Assert that changes were not made
assert:
that:
- not (mk_conn_result_0002 is changed)

125
test/integration/targets/incidental_vmware_guest/tasks/mem_reservation.yml
View file

@ -1,125 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2019, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- when: vcsim is not defined
block:
- &add_mem_reserve
name: Create new VMs with mem_reservation as 0
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
memory_mb: 128
mem_reservation: 0
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: present
folder: "{{ virtual_machines[0].folder }}"
register: mem_reserve_result_0001
- debug: var=mem_reserve_result_0001
- name: Assert that changes were made
assert:
that:
- mem_reserve_result_0001 is changed
- <<: *add_mem_reserve
name: Again create new VMs with mem_reservation as 0
register: mem_reserve_result_0002
- debug: var=mem_reserve_result_0002
- name: Assert that changes were not made
assert:
that:
- not (mem_reserve_result_0002 is changed)
- &add_memory_reserve
name: Create new VM with memory_reservation as 0
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm2
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
memory_mb: 128
memory_reservation: 0
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: present
folder: "{{ virtual_machines[0].folder }}"
register: memory_reserve_result_0003
- debug: var=memory_reserve_result_0003
- name: Assert that changes were made
assert:
that:
- memory_reserve_result_0003 is changed
- <<: *add_memory_reserve
name: Again create new VMs with memory_reservation as 0
register: memory_reserve_result_0004
- debug: var=memory_reserve_result_0004
- name: Assert that changes were not made
assert:
that:
- not (memory_reserve_result_0004 is changed)
- &no_memory_reserve
name: Create new VMs without memory_reservation or mem_reservation
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm3
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
hardware:
num_cpus: 1
memory_mb: 128
memory_reservation: 0
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: present
folder: "{{ virtual_machines[0].folder }}"
register: no_memory_reserve_result_0005
- debug: var=no_memory_reserve_result_0005
- name: Assert that changes were made
assert:
that:
- no_memory_reserve_result_0005 is changed
- <<: *no_memory_reserve
name: Again create new VMs without memory_reservation or mem_reservation
register: no_memory_reserve_result_0006
- debug: var=no_memory_reserve_result_0006
- name: Assert that changes were not made
assert:
that:
- not (no_memory_reserve_result_0006 is changed)

339
test/integration/targets/incidental_vmware_guest/tasks/network_negative_test.yml
View file

@ -1,339 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2018, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- debug: var=f0
- name: create new VMs with non-existent network
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: new_vm
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
disk:
- size: 3mb
type: thin
datastore: "{{ rw_datastore }}"
networks:
- name: "Non existent VM"
hardware:
num_cpus: 1
memory_mb: 128
state: poweredoff
folder: "{{ f0 }}"
register: non_existent_network
ignore_errors: yes
- debug: var=non_existent_network
- name: assert that no changes were not made
assert:
that:
- not (non_existent_network is changed)
- "'does not exist' in non_existent_network.msg"
- name: create new VMs with network and with only IP
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: new_vm
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
disk:
- size: 3mb
type: thin
datastore: "{{ rw_datastore }}"
networks:
- name: "VM Network"
type: static
ip: 10.10.10.10
hardware:
num_cpus: 1
memory_mb: 128
state: poweredoff
folder: "{{ f0 }}"
register: no_netmask
ignore_errors: yes
- debug: var=no_netmask
- name: assert that no changes were not made
assert:
that:
- "not no_netmask.changed"
- "\"'netmask' is required if 'ip' is specified under VM network list.\" in no_netmask.msg"
- name: create new VMs with network and with only netmask
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: new_vm
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
disk:
- size: 3mb
type: thin
datastore: "{{ rw_datastore }}"
networks:
- name: "VM Network"
type: static
netmask: 255.255.255.0
hardware:
num_cpus: 1
memory_mb: 128
state: poweredoff
folder: "{{ f0 }}"
register: no_ip
ignore_errors: yes
- debug: var=no_ip
- name: assert that changes were not made
assert:
that:
- "not no_ip.changed"
- "\"'ip' is required if 'netmask' is specified under VM network list.\" in no_ip.msg"
- name: create new VMs with network and without network name
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: new_vm
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
disk:
- size: 3mb
type: thin
datastore: "{{ rw_datastore }}"
networks:
- ip: 10.10.10.10
netmask: 255.255.255
type: static
hardware:
num_cpus: 1
memory_mb: 128
state: poweredoff
folder: "{{ f0 }}"
register: no_network_name
ignore_errors: yes
- debug: var=no_network_name
- name: assert that no changes were not made
assert:
that:
- "not no_network_name.changed"
- "\"Please specify at least a network name or a VLAN name under VM network list.\" in no_network_name.msg"
- name: create new VMs with network and without network name
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: new_vm
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
disk:
- size: 3mb
type: thin
datastore: "{{ rw_datastore }}"
networks:
- vlan: non_existing_vlan
ip: 10.10.10.10
netmask: 255.255.255
hardware:
num_cpus: 1
memory_mb: 128
state: poweredoff
folder: "{{ f0 }}"
register: no_network
ignore_errors: yes
- debug: var=no_network
- name: assert that changes were not made
assert:
that:
- "not no_network.changed"
- "\"VLAN 'non_existing_vlan' does not exist.\" in no_network.msg"
- name: create new VMs with invalid device type
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: new_vm
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
disk:
- size: 3mb
type: thin
datastore: "{{ rw_datastore }}"
networks:
- name: "VM Network"
ip: 10.10.10.10
netmask: 255.255.255
device_type: abc
hardware:
num_cpus: 1
memory_mb: 128
state: poweredoff
folder: "{{ f0 }}"
register: invalid_device_type
ignore_errors: yes
- debug: var=invalid_device_type
- name: assert that changes were not made
assert:
that:
- "not invalid_device_type.changed"
- "\"Device type specified 'abc' is not valid.\" in invalid_device_type.msg"
- name: create new VMs with invalid device MAC address
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: new_vm
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
disk:
- size: 3mb
type: thin
datastore: "{{ rw_datastore }}"
networks:
- name: "VM Network"
ip: 10.10.10.10
netmask: 255.255.255
device_type: e1000
mac: abcdef
hardware:
num_cpus: 1
memory_mb: 128
state: poweredoff
folder: "{{ f0 }}"
register: invalid_mac
ignore_errors: yes
- debug: var=invalid_mac
- name: assert that changes were not made
assert:
that:
- "not invalid_mac.changed"
- "\"Device MAC address 'abcdef' is invalid.\" in invalid_mac.msg"
- name: create new VMs with invalid network type
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: new_vm
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
disk:
- size: 3mb
type: thin
datastore: "{{ rw_datastore }}"
networks:
- name: "VM Network"
ip: 10.10.10.10
netmask: 255.255.255
device_type: e1000
mac: 01:23:45:67:89:ab
type: aaaaa
hardware:
num_cpus: 1
memory_mb: 128
state: poweredoff
folder: "{{ f0 }}"
register: invalid_network_type
ignore_errors: yes
- debug: var=invalid_network_type
- name: assert that changes were not made
assert:
that:
- "not invalid_network_type.changed"
- "\"Network type 'aaaaa' is not a valid parameter.\" in invalid_network_type.msg"
- name: create new VMs with IP, netmask and network type as "DHCP"
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: new_vm
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
disk:
- size: 3mb
type: thin
datastore: "{{ rw_datastore }}"
networks:
- name: "VM Network"
ip: 10.10.10.10
netmask: 255.255.255
device_type: e1000
mac: 01:23:45:67:89:ab
type: dhcp
hardware:
num_cpus: 1
memory_mb: 128
state: poweredoff
folder: "{{ f0 }}"
register: invalid_dhcp_network_type
ignore_errors: yes
- debug: var=invalid_dhcp_network_type
- name: assert that changes were not made
assert:
that:
- "not invalid_dhcp_network_type.changed"
- "\"Static IP information provided for network\" in invalid_dhcp_network_type.msg"
- name: create new VMs with no network type which set network type as "DHCP"
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
disk:
- size: 3mb
type: thin
datastore: "{{ rw_datastore }}"
networks:
- name: "VM Network"
hardware:
num_cpus: 1
memory_mb: 128
state: poweredoff
folder: "{{ f0 }}"
register: no_network_type
ignore_errors: yes
- debug: var=no_network_type
- name: assert that changes were made
assert:
that:
- "no_network_type.changed"

60
test/integration/targets/incidental_vmware_guest/tasks/network_with_device.yml
View file

@ -1,60 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2018, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
# Testcase to check #38605
- name: Deploy VM first VM
vmware_guest:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
validate_certs: False
datacenter: "{{ dc1 }}"
state: poweredon
folder: "{{ f0 }}"
name: test_vm1
disk:
- size: 10mb
datastore: "{{ rw_datastore }}"
guest_id: rhel7_64guest
hardware:
memory_mb: 128
num_cpus: 1
networks:
- name: 'VM Network'
device_type: "vmxnet3"
register: vm_result
- debug: var=vm_result
- assert:
that:
- "vm_result.changed"
- name: Deploy VM again
vmware_guest:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
validate_certs: False
datacenter: "{{ dc1 }}"
state: poweredon
folder: "{{ f0 }}"
name: test_vm1
disk:
- size: 10mb
datastore: "{{ rw_datastore }}"
guest_id: rhel7_64guest
hardware:
memory_mb: 128
num_cpus: 1
networks:
- name: 'VM Network'
device_type: "vmxnet3"
register: vm_result_again
- debug: var=vm_result_again
- assert:
that:
- not (vm_result_again is changed)

152
test/integration/targets/incidental_vmware_guest/tasks/network_with_dvpg.yml
View file

@ -1,152 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2018, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
# Clone from existing VM with DVPG
- when: vcsim is not defined
block:
- name: Deploy VM from template
vmware_guest:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
validate_certs: no
datacenter: "{{ dc1 }}"
state: poweredon
folder: "{{ f0 }}"
template: "{{ virtual_machines[0].name }}"
name: test_vm1
disk:
- size: 1gb
datastore: "{{ rw_datastore }}"
guest_id: rhel7_64guest
hardware:
memory_mb: 128
num_cpus: 1
networks:
- name: '{{ dvpg1 }}'
register: no_vm_result
- debug: var=no_vm_result
- assert:
that:
- no_vm_result is changed
# New clone with DVPG
- name: Deploy new VM with DVPG
vmware_guest:
esxi_hostname: "{{ esxi_hosts[0] }}"
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
validate_certs: no
datacenter: "{{ dc1 }}"
state: poweredon
folder: "{{ f0 }}"
name: test_vm2
disk:
- size: 1gb
datastore: "{{ rw_datastore }}"
guest_id: rhel7_64guest
hardware:
memory_mb: 128
num_cpus: 1
networks:
- name: '{{ dvpg1 }}'
dvswitch_name: "{{ dvswitch1 }}"
register: no_vm_result
- debug: var=no_vm_result
- assert:
that:
- no_vm_result is changed
- name: Deploy same VM again
vmware_guest:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
validate_certs: no
datacenter: "{{ dc1 }}"
state: poweredon
folder: "{{ f0 }}"
name: test_vm2
disk:
- size: 1gb
datastore: "{{ rw_datastore }}"
guest_id: rhel7_64guest
hardware:
memory_mb: 128
num_cpus: 1
networks:
- name: '{{ dvpg1 }}'
register: no_vm_result
- debug: var=no_vm_result
- assert:
that:
- not (no_vm_result is changed)
- name: Deploy new VM with DVPG with slash in name
vmware_guest:
esxi_hostname: "{{ esxi_hosts[0] }}"
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
validate_certs: no
datacenter: "{{ dc1 }}"
state: poweredon
folder: "{{ f0 }}"
name: test_vm3
disk:
- size: 1gb
datastore: "{{ rw_datastore }}"
guest_id: rhel7_64guest
hardware:
memory_mb: 128
num_cpus: 1
networks:
- name: '{{ dvpg_with_slash }}'
dvswitch_name: "{{ dvswitch1 }}"
register: no_vm_result
- debug: var=no_vm_result
- assert:
that:
- no_vm_result is changed
- name: Deploy same VM again
vmware_guest:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
validate_certs: no
datacenter: "{{ dc1 }}"
state: poweredon
folder: "{{ f0 }}"
name: test_vm3
disk:
- size: 1gb
datastore: "{{ rw_datastore }}"
guest_id: rhel7_64guest
hardware:
memory_mb: 128
num_cpus: 1
networks:
- name: '{{ dvpg_with_slash }}'
register: no_vm_result
- debug: var=no_vm_result
- assert:
that:
- not (no_vm_result is changed)
always:
- when: vcsim is not defined
name: Remove VM to free the portgroup
vmware_guest:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
validate_certs: no
name: '{{ item }}'
force: yes
state: absent
with_items:
- test_vm1
- test_vm2
- test_vm3

47
test/integration/targets/incidental_vmware_guest/tasks/network_with_portgroup.yml
View file

@ -1,47 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2018, Abhijeet Kasurde <akasurde@redhat.com>, Tim Steinbach <tim@nequissimus.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: Add portgroup
vmware_dvs_portgroup:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
portgroup_name: "portgroup_network"
switch_name: "{{ dvswitch1 }}"
vlan_id: "1"
num_ports: 2
portgroup_type: earlyBinding
state: present
register: dvsportgroup
- debug: var=dvsportgroup
- name: create new VMs with portgroup
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
disk:
- size: 3mb
type: thin
datastore: "{{ rw_datastore }}"
networks:
- name: portgroup_network
switch_name: "{{ dvswitch1 }}"
hardware:
num_cpus: 1
memory_mb: 128
state: poweredoff
folder: "{{ f0 }}"
register: vm_with_portgroup
ignore_errors: no
- debug: var=vm_with_portgroup
- assert:
that:
- vm_with_portgroup is changed

23
test/integration/targets/incidental_vmware_guest/tasks/non_existent_vm_ops.yml
View file

@ -1,23 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2018, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: Perform operation on non-existent VM
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: "non_existent_vm"
datacenter: "{{ dc1 }}"
folder: "{{ f0 }}"
state: poweredoff
register: non_existent_vm_ops
ignore_errors: yes
- debug: var=non_existent_vm_ops
- name: assert that changes were not made
assert:
that:
- not (non_existent_vm_ops is changed)
- "'msg' in non_existent_vm_ops"
- "'Unable to find the datastore with given parameters.' in non_existent_vm_ops.msg"

27
test/integration/targets/incidental_vmware_guest/tasks/poweroff_d1_c1_f0.yml
View file

@ -1,27 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2017, James Tanner <tanner.jc@gmail.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: create a VM with the poweroff status
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: "{{ item.name }}"
state: poweredoff
with_items: "{{ virtual_machines }}"
register: poweroff_d1_c1_f0
- debug:
var: poweroff_d1_c1_f0
- name: make sure changes were made
assert:
that:
- poweroff_d1_c1_f0.results[0].instance.hw_power_status == "poweredOff"
- name: make sure no changes were made (the VMs are already off)
assert:
that:
- poweroff_d1_c1_f0.results[0].changed|bool == false

22
test/integration/targets/incidental_vmware_guest/tasks/poweroff_d1_c1_f1.yml
View file

@ -1,22 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2017, James Tanner <tanner.jc@gmail.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
# https://github.com/ansible/ansible/issues/25011
# Sending "-folders 1" to vcsim nests the datacenter under
# the folder so that the path prefix is no longer /vm
#
# /F0/DC0/vm/F0/DC0_H0_VM0
- name: set state to poweredoff on all VMs
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: "{{ item.name }}"
state: poweredoff
folder: "{{ item.folder }}"
with_items: "{{ virtual_machines }}"
register: poweroff_d1_c1_f1
- debug: var=poweroff_d1_c1_f1

73
test/integration/targets/incidental_vmware_guest/tasks/reconfig_vm_to_latest_version.yml
View file

@ -1,73 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2019, Pavan Bidkar <pbidkar@vmware.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
# Skipping out idepotency test untill issue fixed in reconfigure_vm() become_method
- name: Create VM with hardware version 12
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos7_64Guest
datacenter: "{{ dc1 }}"
folder: "{{ f0 }}"
datastore: '{{ rw_datastore }}'
hardware:
num_cpus: 4
memory_mb: 1028
version: 12
state: present
register: create_vm_with_version_12
- name: assert that changes were made
assert:
that:
- create_vm_with_version_12 is changed
- name: Deploy New VM with latest hardware version
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm2
guest_id: centos7_64Guest
datacenter: "{{ dc1 }}"
folder: "{{ f0 }}"
datastore: '{{ rw_datastore }}'
hardware:
num_cpus: 4
memory_mb: 1028
version: latest
state: present
register: deploy_vm_to_latest
- name: assert that changes were made
assert:
that:
- deploy_vm_to_latest is changed
- name: Upgrade VM to latest version
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos7_64Guest
datacenter: "{{ dc1 }}"
folder: "{{ f0 }}"
datastore: '{{ rw_datastore }}'
hardware:
num_cpus: 4
memory_mb: 1028
version: latest
state: present
register: upgrade_vm
- name: assert that changes were made
assert:
that:
- upgrade_vm is changed

61
test/integration/targets/incidental_vmware_guest/tasks/remove_vm_from_inventory.yml
View file

@ -1,61 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2019, Pavan Bidkar <pbidkar@vmware.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- name: Create VM to unregister
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
guest_id: centos64Guest
datacenter: "{{ dc1 }}"
folder: F0
hardware:
num_cpus: 1
num_cpu_cores_per_socket: 1
memory_mb: 128
disk:
- size: 1gb
type: thin
datastore: "{{ rw_datastore }}"
state: present
register: create_vm_for_test
- name: assert that changes were made
assert:
that:
- create_vm_for_test is changed
- name: Remove VM from Inventory
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
delete_from_inventory: True
state: absent
register: remove_vm_from_inventory
- name: assert that changes were made
assert:
that:
- remove_vm_from_inventory is changed
- name: Remove VM again from Inventory
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
name: test_vm1
delete_from_inventory: True
state: absent
register: remove_again_vm_from_inventory
- name: assert that changes were made
assert:
that:
- not (remove_again_vm_from_inventory is changed)

17
test/integration/targets/incidental_vmware_guest/tasks/run_test_playbook.yml
View file

@ -1,17 +0,0 @@
- block:
- include_tasks: '{{ test_playbook }}'
always:
- name: Remove VM
vmware_guest:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
validate_certs: no
# cluster: "{{ ccr1 }}"
name: '{{ item }}'
force: yes
state: absent
with_items:
- test_vm1
- test_vm2
- test_vm3

105
test/integration/targets/incidental_vmware_guest/tasks/template_d1_c1_f0.yml
View file

@ -1,105 +0,0 @@
- name: Create VMs with the poweredoff state
vmware_guest:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
datacenter: "{{ dc1 }}"
validate_certs: no
folder: '{{ f0 }}'
name: 'test_vm1'
state: poweredoff
guest_id: debian8_64Guest
disk:
- size_gb: 1
type: thin
datastore: '{{ rw_datastore }}'
hardware:
memory_mb: 128
num_cpus: 1
scsi: paravirtual
cdrom:
type: iso
iso_path: "[{{ ro_datastore }}] fedora.iso"
networks:
- name: VM Network
- name: ensure that VM1 are not flagged as templates
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
datacenter: "{{ dc1 }}"
folder: "{{ virtual_machines[1].folder }}"
name: "{{ virtual_machines[1].name }}"
state: present
is_template: False
register: no_template_initial
- debug: var=no_template_initial
- name: ensure no changes were made
assert:
that:
- not (no_template_initial is changed)
- name: convert VM1 to template
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
datacenter: "{{ dc1 }}"
folder: "{{ virtual_machines[1].folder }}"
name: "{{ virtual_machines[1].name }}"
state: present
is_template: True
register: convert_to_template
- debug: var=convert_to_template
- name: ensure that changes were made
assert:
that:
- convert_to_template is changed
- name: make double sure that VM1 is template
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
datacenter: "{{ dc1 }}"
folder: "{{ virtual_machines[1].folder }}"
name: "{{ virtual_machines[1].name }}"
state: present
is_template: True
register: still_templates
- debug: var=still_templates
- name: ensure that no changes were made
assert:
that:
- not (still_templates is changed)
# To avoid the follow error of vcsim: VirtualMachine:vm-67 does not implement: MarkAsVirtualMachine
- when: vcsim is not defined
block:
- name: convert template back to VMs
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
datacenter: "{{ dc1 }}"
folder: "{{ virtual_machines[1].folder }}"
name: "{{ virtual_machines[1].name }}"
state: present
is_template: False
register: revert_to_vm
- debug: var=revert_to_vm
- name: ensure that changes were made
assert:
that:
- revert_to_vm is changed

100
test/integration/targets/incidental_vmware_guest/tasks/vapp_d1_c1_f0.yml
View file

@ -1,100 +0,0 @@
# Test code for the vmware_guest module.
# Copyright: (c) 2018, goshkis
# Copyright: (c) 2019, Abhijeet Kasurde <akasurde@redhat.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
- &vapp_new_vm
name: Create test VM with vAPP settings
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
folder: "vm"
name: test_vm1
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
resource_pool: Resources
guest_id: centos64Guest
hardware:
memory_mb: 128
num_cpus: 1
scsi: paravirtual
disk:
- size_mb: 128
type: thin
datastore: "{{ rw_datastore }}"
vapp_properties:
- id: prop_id1
category: category
label: prop_label1
type: string
value: prop_value1
- id: prop_id2
category: category
label: prop_label2
type: string
value: prop_value2
register: vapp_vm
- debug: var=vapp_vm
- name: assert the vApp propeties were created
assert:
that:
- "vapp_vm.failed == false"
- "vapp_vm.changed == true"
- when: vcsim is not defined
block:
- <<: *vapp_new_vm
name: Try to create same VM with same vAPP settings
register: vapp_vm_no_change
- debug: var=vapp_vm_no_change
- name: Assert that vApp properties were not changed
assert:
that:
- "vapp_vm_no_change.failed == false"
- "not vapp_vm_no_change.changed"
- &vapp_edit_vm
name: Edit one vApp property and removing another
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
folder: "vm"
name: test_vm1
datacenter: "{{ dc1 }}"
vapp_properties:
- id: prop_id1
operation: remove
- id: prop_id2
value: prop_value3
state: present
register: vapp_vm
- debug: var=vapp_vm
- name: assert the VM was changed
assert:
that:
- "vapp_vm.failed == false"
- "vapp_vm.changed == true"
- when: vcsim is not defined
block:
- <<: *vapp_edit_vm
name: Try to edit VM with vApp settings
register: vapp_vm_no_change_edit
- debug: var=vapp_vm_no_change_edit
- name: assert the VM was changed
assert:
that:
- "vapp_vm_no_change_edit.failed == false"
- "vapp_vm_no_change_edit.changed == false"

93
test/integration/targets/incidental_vmware_guest/tasks/windows_vbs_d1_c1_f0.yml
View file

@ -1,93 +0,0 @@
- name: Create Windows 10 VM with VBS enabled
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
folder: "{{ f0 }}"
name: vbs-Test
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
resource_pool: Resources
guest_id: windows9_64Guest
hardware:
memory_mb: 128
num_cpus: 1
virt_based_security: True
version: 14
boot_firmware: efi
scsi: paravirtual
disk:
- size_mb: 128
type: thin
datastore: '{{ rw_datastore }}'
cdrom:
type: client
register: vbs_vm
- debug: var=vbs_vm
- name: assert the VM was created
assert:
that:
- "vbs_vm.failed == false"
- "vbs_vm.changed == true"
- name: Create Windows Server 2016 VM without VBS enabled
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
folder: "{{ f0 }}"
name: vbs-Test2
datacenter: "{{ dc1 }}"
cluster: "{{ ccr1 }}"
resource_pool: Resources
guest_id: windows9Server64Guest
hardware:
memory_mb: 128
num_cpus: 1
version: 14
boot_firmware: efi
scsi: paravirtual
disk:
- size_mb: 128
type: thin
datastore: '{{ rw_datastore }}'
cdrom:
type: client
register: vbs_vm
- debug: var=vbs_vm
- name: assert the VM was created
assert:
that:
- "vbs_vm.failed == false"
- "vbs_vm.changed == true"
- name: Enable VBS for Windows Server 2016 VM
vmware_guest:
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
folder: "{{ f0 }}"
name: vbs-Test2
datacenter: "{{ f0 }}"
disk:
- size_mb: 256
type: thin
datastore: '{{ rw_datastore }}'
hardware:
virt_based_security: True
state: present
register: vbs_vm
- debug: var=vbs_vm
- name: assert the VM was changed
assert:
that:
- vbs_vm is changed

3
test/integration/targets/incidental_vmware_host_hyperthreading/aliases
View file

@ -1,3 +0,0 @@
cloud/vcenter
shippable/vcenter/incidental
needs/target/incidental_vmware_prepare_tests

92
test/integration/targets/incidental_vmware_host_hyperthreading/tasks/main.yml
View file

@ -1,92 +0,0 @@
# Test code for the vmware_host_hyperthreading module.
# Copyright: (c) 2018, Christian Kotte <christian.kotte@gmx.de>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
# Hyperthreading optimization is not available for hosts in vcsim
- import_role:
name: incidental_vmware_prepare_tests
vars:
setup_attach_host: true
- name: Enable Hyperthreading everywhere
vmware_host_hyperthreading:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
validate_certs: no
state: disabled
register: enable_hyperthreading_everywhere
ignore_errors: true
- when: enable_hyperthreading_everywhere is succeeded
block:
- name: Disable Hyperthreading for a given host
vmware_host_hyperthreading:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
esxi_hostname: '{{ esxi1 }}'
validate_certs: no
state: disabled
register: host_hyperthreading_info
- debug: var=host_hyperthreading_info
- assert:
that:
- host_hyperthreading_info is defined
- host_hyperthreading_info.changed
- name: Disable Hyperthreading for a given host in check mode
vmware_host_hyperthreading:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
esxi_hostname: '{{ esxi1 }}'
validate_certs: no
state: disabled
register: host_hyperthreading_info_check_mode
check_mode: yes
- debug: var=host_hyperthreading_info_check_mode
- assert:
that:
- host_hyperthreading_info_check_mode is defined
- name: Disable Hyperthreading for all hosts in given cluster
vmware_host_hyperthreading:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
cluster_name: "{{ ccr1 }}"
validate_certs: no
state: disabled
register: host_hyperthreading_info
- debug: var=host_hyperthreading_info
- assert:
that:
- host_hyperthreading_info is defined
- host_hyperthreading_info is changed
- name: Enable Hyperthreading for all hosts in given cluster in check mode
vmware_host_hyperthreading:
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
cluster_name: "{{ ccr1 }}"
validate_certs: no
state: enabled
register: host_hyperthreading_info_check_mode
check_mode: yes
- debug: var=host_hyperthreading_info_check_mode
- assert:
that:
- host_hyperthreading_info_check_mode is defined
- host_hyperthreading_info_check_mode.changed

1
test/integration/targets/incidental_vmware_prepare_tests/aliases
View file

@ -1 +0,0 @@
hidden

2
test/integration/targets/incidental_vmware_prepare_tests/meta/main.yml
View file

@ -1,2 +0,0 @@
---
allow_duplicates: true

29
test/integration/targets/incidental_vmware_prepare_tests/tasks/init_real_lab.yml
View file

@ -1,29 +0,0 @@
---
- include_tasks: teardown_with_esxi.yml
when: esxi_hosts|length > 0
- include_tasks: teardown.yml
- when: setup_esxi_instance is not defined
block:
- include_tasks: setup_datacenter.yml
- include_tasks: setup_cluster.yml
- include_tasks: setup_attach_hosts.yml
when: setup_attach_host is defined
- include_tasks: setup_datastore.yml
when: setup_datastore is defined
- include_tasks: setup_virtualmachines.yml
when: setup_virtualmachines is defined
- include_tasks: setup_switch.yml
when: setup_switch is defined
- include_tasks: setup_dvswitch.yml
when: setup_dvswitch is defined
- include_tasks: setup_resource_pool.yml
when: setup_resource_pool is defined
- include_tasks: setup_category.yml
when: setup_category is defined
- include_tasks: setup_tag.yml
when: setup_tag is defined
- include_tasks: setup_content_library.yml
when: setup_content_library is defined
- include_tasks: setup_dvs_portgroup.yml
when: setup_dvs_portgroup is defined

48
test/integration/targets/incidental_vmware_prepare_tests/tasks/init_vcsim.yml
View file

@ -1,48 +0,0 @@
---
- name: load vars
include_vars:
file: vcsim.yml
- name: kill vcsim
uri:
url: http://{{ vcsim }}:5000/killall
- name: start vcsim (all dressed)
uri:
url: http://{{ vcsim }}:5000/spawn?cluster=1&folder=1&ds=2
register: vcsim_instance
when: setup_esxi_instance is not defined
- name: start vcsim (ESXi only)
uri:
url: http://{{ vcsim }}:5000/spawn?esx=1
register: vcsim_instance
when: setup_esxi_instance is defined
# - name: get a list of Hosts from vcsim
# uri:
# url: http://{{ vcsim }}:5000/govc_find?filter=H
# register: vcsim_host_list
# - name: get a list of Hosts from vcsim
# uri:
# url: http://{{ vcsim }}:5000/govc_find?filter=F
# register: vcsim_host_folder
# - debug: var=vcsim_host_folder
- set_fact:
vcenter_hostname: "{{ vcsim }}"
vcenter_username: "user"
vcenter_password: "pass"
- name: set state to poweroff on all VMs
vmware_guest:
name: "{{ item.name }}"
state: poweredoff
validate_certs: False
hostname: "{{ vcenter_hostname }}"
username: "{{ vcenter_username }}"
password: "{{ vcenter_password }}"
with_items: "{{ virtual_machines + virtual_machines_in_cluster }}"
register: poweroff_d1_c1_f0

25
test/integration/targets/incidental_vmware_prepare_tests/tasks/main.yml
View file

@ -1,25 +0,0 @@
---
- name: load vmware common vars
include_vars:
file: common.yml
- when: vcsim is not defined
block:
- when: esxi1_hostname is not defined and esxi2_hostname is not defined
include_vars:
file: vcenter_only.yml
- when: esxi1_hostname is defined and esxi2_hostname is not defined
include_vars:
file: vcenter_1esxi.yml
- when: esxi1_hostname is defined and esxi2_hostname is defined
include_vars:
file: vcenter_2esxi.yml
- when: vcsim is not defined
include_tasks: init_real_lab.yml
- when: vcsim is defined
include_tasks: init_vcsim.yml

30
test/integration/targets/incidental_vmware_prepare_tests/tasks/setup_attach_hosts.yml
View file

@ -1,30 +0,0 @@
- fail:
msg: "No ESXi hosts defined. esxi_hosts is empty."
when: "esxi_hosts|length == 0"
- name: Add ESXi Hosts to vCenter
vmware_host:
datacenter_name: '{{ dc1 }}'
cluster_name: '{{ ccr1 }}'
esxi_hostname: '{{ item }}'
esxi_username: '{{ esxi_user }}'
esxi_password: '{{ esxi_password }}'
state: add_or_reconnect
with_items: "{{ esxi_hosts }}"
- name: Disable the Maintenance Mode
vmware_maintenancemode:
esxi_hostname: '{{ item }}'
state: absent
with_items: "{{ esxi_hosts }}"
- name: Add Management Network VM Portgroup
vmware_portgroup:
hostname: '{{ item }}'
username: '{{ esxi_user }}'
password: '{{ esxi_password }}'
esxi_hostname: 'item'
switch: "vSwitch0"
portgroup: VM Network
validate_certs: no
with_items: "{{ esxi_hosts }}"

5
test/integration/targets/incidental_vmware_prepare_tests/tasks/setup_category.yml
View file

@ -1,5 +0,0 @@
- name: Create a category for cluster
vmware_category:
category_name: '{{ cluster_category }}'
category_description: '{{ cluster_category }} description'
state: present

10
test/integration/targets/incidental_vmware_prepare_tests/tasks/setup_cluster.yml
View file

@ -1,10 +0,0 @@
- name: Create Cluster
vmware_cluster:
datacenter_name: '{{ dc1 }}'
cluster_name: '{{ ccr1 }}'
- name: Enable DRS on Cluster
vmware_cluster_drs:
datacenter_name: '{{ dc1 }}'
cluster_name: '{{ ccr1 }}'
enable_drs: yes

7
test/integration/targets/incidental_vmware_prepare_tests/tasks/setup_content_library.yml
View file

@ -1,7 +0,0 @@
- name: Create Content Library
vmware_content_library_manager:
library_name: test-content-lib
library_description: 'Library created by the prepare_vmware_tests role'
library_type: local
datastore_name: '{{ rw_datastore }}'
state: present

11
test/integration/targets/incidental_vmware_prepare_tests/tasks/setup_datacenter.yml
View file

@ -1,11 +0,0 @@
- name: Create Datacenter
vmware_datacenter:
datacenter_name: '{{ dc1 }}'
state: present
- name: Create a VM folder on given Datacenter
vcenter_folder:
datacenter: '{{ dc1 }}'
folder_name: '{{ f0 }}'
folder_type: vm
state: present

42
test/integration/targets/incidental_vmware_prepare_tests/tasks/setup_datastore.yml
View file

@ -1,42 +0,0 @@
---
- name: Mount NFS (ro_datastore) datastores to ESXi
vmware_host_datastore:
hostname: '{{ item }}'
username: '{{ esxi_user }}'
password: '{{ esxi_password }}'
datastore_name: '{{ ro_datastore }}'
datastore_type: '{{ infra.datastores[ro_datastore].type }}'
nfs_server: '{{ infra.datastores[ro_datastore].server }}'
nfs_path: '{{ infra.datastores[ro_datastore].path }}'
nfs_ro: '{{ infra.datastores[ro_datastore].ro }}'
state: present
validate_certs: no
with_items: "{{ esxi_hosts }}"
- name: Mount NFS (rw_datastore) datastores on the ESXi
vmware_host_datastore:
hostname: '{{ item }}'
username: '{{ esxi_user }}'
password: '{{ esxi_password }}'
datastore_name: '{{ rw_datastore }}'
datastore_type: '{{ infra.datastores[rw_datastore].type }}'
nfs_server: '{{ infra.datastores[rw_datastore].server }}'
nfs_path: '{{ infra.datastores[rw_datastore].path }}'
nfs_ro: '{{ infra.datastores[rw_datastore].ro }}'
state: present
validate_certs: no
with_items: "{{ esxi_hosts }}"
- vmware_host_scanhba:
refresh_storage: true
cluster_name: '{{ ccr1 }}'
- name: The vcenter needs a bit of time to refresh the DS list
vmware_datastore_info:
validate_certs: false
cluster: '{{ ccr1 }}'
register: setup_datastore_datatstore_info
failed_when: setup_datastore_datatstore_info.datastores|selectattr('type', 'equalto', 'NFS')|list|length != 2
until: setup_datastore_datatstore_info is succeeded
retries: 60
delay: 1

18
test/integration/targets/incidental_vmware_prepare_tests/tasks/setup_dvs_portgroup.yml
View file

@ -1,18 +0,0 @@
---
- name: create basic DVS portgroup
vmware_dvs_portgroup:
switch_name: "{{ dvswitch1 }}"
portgroup_name: '{{ dvpg1 }}'
vlan_id: 0
num_ports: 32
portgroup_type: earlyBinding
state: present
- name: Create the DVS PG with slash in name
vmware_dvs_portgroup:
portgroup_name: '{{ dvpg_with_slash }}'
switch_name: '{{ dvswitch1 }}'
vlan_id: 0
num_ports: 120
portgroup_type: earlyBinding
state: present

20
test/integration/targets/incidental_vmware_prepare_tests/tasks/setup_dvswitch.yml
View file

@ -1,20 +0,0 @@
---
- name: Create the DVSwitch
vmware_dvswitch:
datacenter_name: '{{ dc1 }}'
switch_name: '{{ dvswitch1 }}'
switch_version: 6.0.0
mtu: 9000
uplink_quantity: 2
discovery_proto: lldp
discovery_operation: both
state: present
- name: Attach the hosts to the DVSwitch
vmware_dvs_host:
esxi_hostname: "{{ item }}"
switch_name: '{{ dvswitch1 }}'
vmnics:
- vmnic1
state: present
with_items: "{{ esxi_hosts }}"
when: setup_attach_host is defined

15
test/integration/targets/incidental_vmware_prepare_tests/tasks/setup_resource_pool.yml
View file

@ -1,15 +0,0 @@
---
- name: Add resource pool to vCenter
vmware_resource_pool:
datacenter: '{{ dc1 }}'
cluster: '{{ ccr1 }}'
resource_pool: DC0_C0_RP1
mem_shares: normal
mem_limit: -1
mem_reservation: 0
mem_expandable_reservations: yes
cpu_shares: normal
cpu_limit: -1
cpu_reservation: 0
cpu_expandable_reservations: yes
state: present

7
test/integration/targets/incidental_vmware_prepare_tests/tasks/setup_switch.yml
View file

@ -1,7 +0,0 @@
---
- name: Add a VMware vSwitchs
vmware_vswitch:
esxi_hostname: '{{ item }}'
switch_name: "{{ switch1 }}"
state: present
with_items: "{{ esxi_hosts }}"

15
test/integration/targets/incidental_vmware_prepare_tests/tasks/setup_tag.yml
View file

@ -1,15 +0,0 @@
- name: Get Category facts
vmware_category_info:
register: cat_info
- name: Get Category id for {{ cluster_category }}
set_fact:
cluster_category_id: "{{ cat_info.tag_category_info[0].category_id }}"
- name: Create a tag for cluster
vmware_tag:
category_id: '{{ cluster_category_id }}'
tag_name: '{{ cluster_tag }}'
tag_description: '{{ cluster_tag }} Description'
state: present
when: cluster_category_id is defined

46
test/integration/targets/incidental_vmware_prepare_tests/tasks/setup_virtualmachines.yml
View file

@ -1,46 +0,0 @@
---
- name: Create VMs
vmware_guest:
datacenter: "{{ dc1 }}"
folder: '{{ item.folder }}'
name: '{{ item.name }}'
state: poweredoff
guest_id: debian8_64Guest
disk:
- size_gb: 1
type: thin
datastore: '{{ rw_datastore }}'
hardware:
memory_mb: 128
num_cpus: 1
scsi: paravirtual
cdrom:
type: iso
iso_path: "[{{ ro_datastore }}] fedora.iso"
networks:
- name: VM Network
with_items: '{{ virtual_machines }}'
- name: Create VMs in cluster
vmware_guest:
datacenter: "{{ dc1 }}"
folder: '{{ item.folder }}'
cluster: '{{ item.cluster }}'
name: '{{ item.name }}'
state: poweredoff
guest_id: debian8_64Guest
disk:
- size_gb: 1
type: thin
datastore: '{{ rw_datastore }}'
hardware:
memory_mb: 128
num_cpus: 1
scsi: paravirtual
cdrom:
type: iso
iso_path: "[{{ ro_datastore }}] fedora.iso"
networks:
- name: VM Network
with_items: '{{ virtual_machines_in_cluster }}'

24
test/integration/targets/incidental_vmware_prepare_tests/tasks/teardown.yml
View file

@ -1,24 +0,0 @@
---
- name: Delete a datastore cluster to datacenter
vmware_datastore_cluster:
datacenter_name: "{{ dc1 }}"
datastore_cluster_name: '{{ item }}'
state: absent
with_items:
- DSC1
- DSC2
ignore_errors: yes
- name: Remove the datacenter
vmware_datacenter:
datacenter_name: '{{ item }}'
state: absent
when: vcsim is not defined
with_items:
- '{{ dc1 }}'
- datacenter_0001
- name: kill vcsim
uri:
url: "http://{{ vcsim }}:5000/killall"
when: vcsim is defined

96
test/integration/targets/incidental_vmware_prepare_tests/tasks/teardown_with_esxi.yml
View file

@ -1,96 +0,0 @@
---
- name: Clean up the firewall rules
vmware_host_firewall_manager:
cluster_name: '{{ ccr1 }}'
rules:
- name: vvold
enabled: False
- name: CIMHttpServer
enabled: True
allowed_hosts:
all_ip: True
- name: NFC
enabled: True
allowed_hosts:
all_ip: True
ignore_errors: yes
- name: Remove the VM prepared by prepare_vmware_tests
vmware_guest:
name: "{{ item.name }}"
force: yes
state: absent
with_items: '{{ virtual_machines + virtual_machines_in_cluster }}'
- name: Remove the test_vm* VMs
vmware_guest:
name: "{{ item }}"
force: yes
state: absent
with_items:
- test_vm1
- test_vm2
- test_vm3
- name: Remove the DVS portgroups
vmware_dvs_portgroup:
switch_name: "{{ dvswitch1 }}"
portgroup_name: '{{ item }}'
vlan_id: 0
num_ports: 32
portgroup_type: earlyBinding
state: absent
loop:
- DC0_DVPG0
- DVPG/1
ignore_errors: yes
- name: Remove the DVSwitch
vmware_dvswitch:
datacenter_name: '{{ dc1 }}'
state: absent
switch_name: '{{ item }}'
loop:
- '{{ dvswitch1 }}'
- dvswitch_0001
- dvswitch_0002
ignore_errors: yes
- name: Remove the vSwitches
vmware_vswitch:
hostname: '{{ item }}'
username: '{{ esxi_user }}'
password: '{{ esxi_password }}'
switch_name: "{{ switch1 }}"
state: absent
with_items: "{{ esxi_hosts }}"
ignore_errors: yes
- name: Remove ESXi Hosts to vCenter
vmware_host:
datacenter_name: '{{ dc1 }}'
cluster_name: ccr1
esxi_hostname: '{{ item }}'
esxi_username: '{{ esxi_user }}'
esxi_password: '{{ esxi_password }}'
state: absent
with_items: "{{ esxi_hosts }}"
ignore_errors: yes
- name: Umount NFS datastores to ESXi (1/2)
vmware_host_datastore:
hostname: '{{ item }}'
username: '{{ esxi_user }}'
password: '{{ esxi_password }}'
datastore_name: '{{ ro_datastore }}'
state: absent
with_items: "{{ esxi_hosts }}"
- name: Umount NFS datastores to ESXi (2/2)
vmware_host_datastore:
hostname: '{{ item }}'
username: '{{ esxi_user }}'
password: '{{ esxi_password }}'
datastore_name: '{{ rw_datastore }}'
state: absent
with_items: "{{ esxi_hosts }}"

12
test/integration/targets/incidental_vmware_prepare_tests/vars/common.yml
View file

@ -1,12 +0,0 @@
---
dc1: DC0
ccr1: DC0_C0
f0: F0
switch1: switch1
esxi1: '{{ esxi_hosts[0] }}'
esxi2: '{{ esxi_hosts[1] }}'
esxi3: '{{ esxi_hosts[2] }}'
dvswitch1: DVS0
esxi_user: root
dvpg1: DC0_DVPG0
dvpg_with_slash: DVPG/1

33
test/integration/targets/incidental_vmware_prepare_tests/vars/vcenter_1esxi.yml
View file

@ -1,33 +0,0 @@
---
esxi_hosts:
- esxi1.test
rw_datastore: rw_datastore
ro_datastore: ro_datastore
esxi_password: '{{ esxi1_password }}'
esxi_user: '{{ esxi1_username }}'
infra:
datastores:
rw_datastore:
type: nfs
server: datastore.test
path: /srv/share/vms
ro: false
ro_datastore:
type: nfs
server: datastore.test
path: /srv/share/isos
ro: true
virtual_machines:
- name: DC0_H0_VM0
folder: '{{ f0 }}'
- name: DC0_H0_VM1
folder: '{{ f0 }}'
virtual_machines_in_cluster:
- name: DC0_C0_RP0_VM0
folder: '{{ f0 }}'
cluster: '{{ ccr1 }}'
- name: DC0_C0_RP0_VM1
folder: '{{ f0 }}'
cluster: '{{ ccr1 }}'
cluster_tag: test_cluster_tag_0001
cluster_category: test_cluster_cat_0001

34
test/integration/targets/incidental_vmware_prepare_tests/vars/vcenter_2esxi.yml
View file

@ -1,34 +0,0 @@
---
esxi_hosts:
- esxi1.test
- esxi2.test
rw_datastore: rw_datastore
ro_datastore: ro_datastore
esxi_password: '{{ esxi1_password }}'
esxi_user: '{{ esxi1_username }}'
infra:
datastores:
rw_datastore:
type: nfs
server: datastore.test
path: /srv/share/vms
ro: false
ro_datastore:
type: nfs
server: datastore.test
path: /srv/share/isos
ro: true
virtual_machines:
- name: DC0_H0_VM0
folder: '{{ f0 }}'
- name: DC0_H0_VM1
folder: '{{ f0 }}'
virtual_machines_in_cluster:
- name: DC0_C0_RP0_VM0
folder: '{{ f0 }}'
cluster: '{{ ccr1 }}'
- name: DC0_C0_RP0_VM1
folder: '{{ f0 }}'
cluster: '{{ ccr1 }}'
cluster_tag: test_cluster_tag_0001
cluster_category: test_cluster_cat_0001

6
test/integration/targets/incidental_vmware_prepare_tests/vars/vcenter_only.yml
View file

@ -1,6 +0,0 @@
---
esxi_hosts: []
infra:
virtual_machines: []
virtual_machines_in_cluster: []
#esxi_password: ''

19
test/integration/targets/incidental_vmware_prepare_tests/vars/vcsim.yml
View file

@ -1,19 +0,0 @@
---
esxi_hosts:
- DC0_C0_H0
- DC0_C0_H1
- DC0_C0_H2
esxi_password: 'pass'
esxi_user: 'user'
rw_datastore: LocalDS_0
ro_datastore: LocalDS_1
virtual_machines:
- name: DC0_H0_VM0
folder: /F0/DC0/vm/F0
- name: DC0_H0_VM1
folder: /F0/DC0/vm/F0
virtual_machines_in_cluster:
- name: DC0_C0_RP0_VM0
cluster: '{{ ccr1 }}'
- name: DC0_C0_RP0_VM1
cluster: '{{ ccr1 }}'

1
test/integration/targets/inventory_script/aliases Normal file
View file

@ -0,0 +1 @@
shippable/posix/group1

1045
test/integration/targets/inventory_script/inventory.json Normal file
View file

File diff suppressed because it is too large Load diff

7
test/integration/targets/inventory_script/inventory.sh Executable file
View file

@ -0,0 +1,7 @@
#!/bin/sh
# This script mimics the output from what the contrib/inventory/vmware_inventory.py
# dynamic inventory script produced.
# This ensures we are still covering the same code that the original tests gave us
# and subsequently ensures that ansible-inventory produces output consistent with
# that of a dynamic inventory script
cat inventory.json

5
test/integration/targets/inventory_script/runme.sh Executable file
View file

@ -0,0 +1,5 @@
#!/usr/bin/env bash
set -eux
diff -uw <(ansible-inventory -i inventory.sh --list --export) inventory.json

3
test/integration/targets/plugin_config_for_inventory/test_inventory.py
View file

@ -64,7 +64,8 @@ class InventoryModule(BaseInventoryPlugin):
def parse(self, inventory, loader, path, cache=True):
super(InventoryModule, self).parse(inventory, loader, path)
self._read_config_data(path=path)
config_data = self._read_config_data(path=path)
self._consume_options(config_data)
departments = self.get_option('departments')

477
test/support/integration/plugins/inventory/vmware_vm_inventory.py
View file

@ -1,477 +0,0 @@
#
# Copyright: (c) 2018, Ansible Project
# Copyright: (c) 2018, Abhijeet Kasurde <akasurde@redhat.com>
#
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type
DOCUMENTATION = '''
name: vmware_vm_inventory
plugin_type: inventory
short_description: VMware Guest inventory source
version_added: "2.7"
author:
- Abhijeet Kasurde (@Akasurde)
description:
- Get virtual machines as inventory hosts from VMware environment.
- Uses any file which ends with vmware.yml, vmware.yaml, vmware_vm_inventory.yml, or vmware_vm_inventory.yaml as a YAML configuration file.
- The inventory_hostname is always the 'Name' and UUID of the virtual machine. UUID is added as VMware allows virtual machines with the same name.
extends_documentation_fragment:
- inventory_cache
requirements:
- "Python >= 2.7"
- "PyVmomi"
- "requests >= 2.3"
- "vSphere Automation SDK - For tag feature"
- "vCloud Suite SDK - For tag feature"
options:
hostname:
description: Name of vCenter or ESXi server.
required: True
env:
- name: VMWARE_HOST
- name: VMWARE_SERVER
username:
description: Name of vSphere admin user.
required: True
env:
- name: VMWARE_USER
- name: VMWARE_USERNAME
password:
description: Password of vSphere admin user.
required: True
env:
- name: VMWARE_PASSWORD
port:
description: Port number used to connect to vCenter or ESXi Server.
default: 443
env:
- name: VMWARE_PORT
validate_certs:
description:
- Allows connection when SSL certificates are not valid. Set to C(false) when certificates are not trusted.
default: True
type: boolean
env:
- name: VMWARE_VALIDATE_CERTS
with_tags:
description:
- Include tags and associated virtual machines.
- Requires 'vSphere Automation SDK' library to be installed on the given controller machine.
- Please refer following URLs for installation steps
- 'https://code.vmware.com/web/sdk/65/vsphere-automation-python'
default: False
type: boolean
properties:
description:
- Specify the list of VMware schema properties associated with the VM.
- These properties will be populated in hostvars of the given VM.
- Each value in the list specifies the path to a specific property in VM object.
type: list
default: [ 'name', 'config.cpuHotAddEnabled', 'config.cpuHotRemoveEnabled',
'config.instanceUuid', 'config.hardware.numCPU', 'config.template',
'config.name', 'guest.hostName', 'guest.ipAddress',
'guest.guestId', 'guest.guestState', 'runtime.maxMemoryUsage',
'customValue'
]
version_added: "2.9"
'''
EXAMPLES = '''
# Sample configuration file for VMware Guest dynamic inventory
plugin: vmware_vm_inventory
strict: False
hostname: 10.65.223.31
username: administrator@vsphere.local
password: Esxi@123$%
validate_certs: False
with_tags: True
# Gather minimum set of properties for VMware guest
plugin: vmware_vm_inventory
strict: False
hostname: 10.65.223.31
username: administrator@vsphere.local
password: Esxi@123$%
validate_certs: False
with_tags: False
properties:
- 'name'
- 'guest.ipAddress'
'''
import ssl
import atexit
from ansible.errors import AnsibleError, AnsibleParserError
try:
# requests is required for exception handling of the ConnectionError
import requests
HAS_REQUESTS = True
except ImportError:
HAS_REQUESTS = False
try:
from pyVim import connect
from pyVmomi import vim, vmodl
HAS_PYVMOMI = True
except ImportError:
HAS_PYVMOMI = False
try:
from com.vmware.vapi.std_client import DynamicID
from vmware.vapi.vsphere.client import create_vsphere_client
HAS_VSPHERE = True
except ImportError:
HAS_VSPHERE = False
from ansible.plugins.inventory import BaseInventoryPlugin, Cacheable
class BaseVMwareInventory:
def __init__(self, hostname, username, password, port, validate_certs, with_tags):
self.hostname = hostname
self.username = username
self.password = password
self.port = port
self.with_tags = with_tags
self.validate_certs = validate_certs
self.content = None
self.rest_content = None
def do_login(self):
"""
Check requirements and do login
"""
self.check_requirements()
self.content = self._login()
if self.with_tags:
self.rest_content = self._login_vapi()
def _login_vapi(self):
"""
Login to vCenter API using REST call
Returns: connection object
"""
session = requests.Session()
session.verify = self.validate_certs
if not self.validate_certs:
# Disable warning shown at stdout
requests.packages.urllib3.disable_warnings()
server = self.hostname
if self.port:
server += ":" + str(self.port)
client = create_vsphere_client(server=server,
username=self.username,
password=self.password,
session=session)
if client is None:
raise AnsibleError("Failed to login to %s using %s" % (server, self.username))
return client
def _login(self):
"""
Login to vCenter or ESXi server
Returns: connection object
"""
if self.validate_certs and not hasattr(ssl, 'SSLContext'):
raise AnsibleError('pyVim does not support changing verification mode with python < 2.7.9. Either update '
'python or set validate_certs to false in configuration YAML file.')
ssl_context = None
if not self.validate_certs and hasattr(ssl, 'SSLContext'):
ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
ssl_context.verify_mode = ssl.CERT_NONE
service_instance = None
try:
service_instance = connect.SmartConnect(host=self.hostname, user=self.username,
pwd=self.password, sslContext=ssl_context,
port=self.port)
except vim.fault.InvalidLogin as e:
raise AnsibleParserError("Unable to log on to vCenter or ESXi API at %s:%s as %s: %s" % (self.hostname, self.port, self.username, e.msg))
except vim.fault.NoPermission as e:
raise AnsibleParserError("User %s does not have required permission"
" to log on to vCenter or ESXi API at %s:%s : %s" % (self.username, self.hostname, self.port, e.msg))
except (requests.ConnectionError, ssl.SSLError) as e:
raise AnsibleParserError("Unable to connect to vCenter or ESXi API at %s on TCP/%s: %s" % (self.hostname, self.port, e))
except vmodl.fault.InvalidRequest as e:
# Request is malformed
raise AnsibleParserError("Failed to get a response from server %s:%s as "
"request is malformed: %s" % (self.hostname, self.port, e.msg))
except Exception as e:
raise AnsibleParserError("Unknown error while connecting to vCenter or ESXi API at %s:%s : %s" % (self.hostname, self.port, e))
if service_instance is None:
raise AnsibleParserError("Unknown error while connecting to vCenter or ESXi API at %s:%s" % (self.hostname, self.port))
atexit.register(connect.Disconnect, service_instance)
return service_instance.RetrieveContent()
def check_requirements(self):
""" Check all requirements for this inventory are satisified"""
if not HAS_REQUESTS:
raise AnsibleParserError('Please install "requests" Python module as this is required'
' for VMware Guest dynamic inventory plugin.')
elif not HAS_PYVMOMI:
raise AnsibleParserError('Please install "PyVmomi" Python module as this is required'
' for VMware Guest dynamic inventory plugin.')
if HAS_REQUESTS:
# Pyvmomi 5.5 and onwards requires requests 2.3
# https://github.com/vmware/pyvmomi/blob/master/requirements.txt
required_version = (2, 3)
requests_version = requests.__version__.split(".")[:2]
try:
requests_major_minor = tuple(map(int, requests_version))
except ValueError:
raise AnsibleParserError("Failed to parse 'requests' library version.")
if requests_major_minor < required_version:
raise AnsibleParserError("'requests' library version should"
" be >= %s, found: %s." % (".".join([str(w) for w in required_version]),
requests.__version__))
if not HAS_VSPHERE and self.with_tags:
raise AnsibleError("Unable to find 'vSphere Automation SDK' Python library which is required."
" Please refer this URL for installation steps"
" - https://code.vmware.com/web/sdk/65/vsphere-automation-python")
if not all([self.hostname, self.username, self.password]):
raise AnsibleError("Missing one of the following : hostname, username, password. Please read "
"the documentation for more information.")
def _get_managed_objects_properties(self, vim_type, properties=None):
"""
Look up a Managed Object Reference in vCenter / ESXi Environment
:param vim_type: Type of vim object e.g, for datacenter - vim.Datacenter
:param properties: List of properties related to vim object e.g. Name
:return: local content object
"""
# Get Root Folder
root_folder = self.content.rootFolder
if properties is None:
properties = ['name']
# Create Container View with default root folder
mor = self.content.viewManager.CreateContainerView(root_folder, [vim_type], True)
# Create Traversal spec
traversal_spec = vmodl.query.PropertyCollector.TraversalSpec(
name="traversal_spec",
path='view',
skip=False,
type=vim.view.ContainerView
)
# Create Property Spec
property_spec = vmodl.query.PropertyCollector.PropertySpec(
type=vim_type, # Type of object to retrieved
all=False,
pathSet=properties
)
# Create Object Spec
object_spec = vmodl.query.PropertyCollector.ObjectSpec(
obj=mor,
skip=True,
selectSet=[traversal_spec]
)
# Create Filter Spec
filter_spec = vmodl.query.PropertyCollector.FilterSpec(
objectSet=[object_spec],
propSet=[property_spec],
reportMissingObjectsInResults=False
)
return self.content.propertyCollector.RetrieveContents([filter_spec])
@staticmethod
def _get_object_prop(vm, attributes):
"""Safely get a property or return None"""
result = vm
for attribute in attributes:
try:
result = getattr(result, attribute)
except (AttributeError, IndexError):
return None
return result
class InventoryModule(BaseInventoryPlugin, Cacheable):
NAME = 'vmware_vm_inventory'
def verify_file(self, path):
"""
Verify plugin configuration file and mark this plugin active
Args:
path: Path of configuration YAML file
Returns: True if everything is correct, else False
"""
valid = False
if super(InventoryModule, self).verify_file(path):
if path.endswith(('vmware.yaml', 'vmware.yml', 'vmware_vm_inventory.yaml', 'vmware_vm_inventory.yml')):
valid = True
return valid
def parse(self, inventory, loader, path, cache=True):
"""
Parses the inventory file
"""
super(InventoryModule, self).parse(inventory, loader, path, cache=cache)
cache_key = self.get_cache_key(path)
config_data = self._read_config_data(path)
# set _options from config data
self._consume_options(config_data)
self.pyv = BaseVMwareInventory(
hostname=self.get_option('hostname'),
username=self.get_option('username'),
password=self.get_option('password'),
port=self.get_option('port'),
with_tags=self.get_option('with_tags'),
validate_certs=self.get_option('validate_certs')
)
self.pyv.do_login()
self.pyv.check_requirements()
source_data = None
if cache:
cache = self.get_option('cache')
update_cache = False
if cache:
try:
source_data = self._cache[cache_key]
except KeyError:
update_cache = True
using_current_cache = cache and not update_cache
cacheable_results = self._populate_from_source(source_data, using_current_cache)
if update_cache:
self._cache[cache_key] = cacheable_results
def _populate_from_cache(self, source_data):
""" Populate cache using source data """
hostvars = source_data.pop('_meta', {}).get('hostvars', {})
for group in source_data:
if group == 'all':
continue
else:
self.inventory.add_group(group)
hosts = source_data[group].get('hosts', [])
for host in hosts:
self._populate_host_vars([host], hostvars.get(host, {}), group)
self.inventory.add_child('all', group)
def _populate_from_source(self, source_data, using_current_cache):
"""
Populate inventory data from direct source
"""
if using_current_cache:
self._populate_from_cache(source_data)
return source_data
cacheable_results = {'_meta': {'hostvars': {}}}
hostvars = {}
objects = self.pyv._get_managed_objects_properties(vim_type=vim.VirtualMachine,
properties=['name'])
if self.pyv.with_tags:
tag_svc = self.pyv.rest_content.tagging.Tag
tag_association = self.pyv.rest_content.tagging.TagAssociation
tags_info = dict()
tags = tag_svc.list()
for tag in tags:
tag_obj = tag_svc.get(tag)
tags_info[tag_obj.id] = tag_obj.name
if tag_obj.name not in cacheable_results:
cacheable_results[tag_obj.name] = {'hosts': []}
self.inventory.add_group(tag_obj.name)
for vm_obj in objects:
for vm_obj_property in vm_obj.propSet:
# VMware does not provide a way to uniquely identify VM by its name
# i.e. there can be two virtual machines with same name
# Appending "_" and VMware UUID to make it unique
if not vm_obj.obj.config:
# Sometime orphaned VMs return no configurations
continue
current_host = vm_obj_property.val + "_" + vm_obj.obj.config.uuid
if current_host not in hostvars:
hostvars[current_host] = {}
self.inventory.add_host(current_host)
host_ip = vm_obj.obj.guest.ipAddress
if host_ip:
self.inventory.set_variable(current_host, 'ansible_host', host_ip)
self._populate_host_properties(vm_obj, current_host)
# Only gather facts related to tag if vCloud and vSphere is installed.
if HAS_VSPHERE and self.pyv.with_tags:
# Add virtual machine to appropriate tag group
vm_mo_id = vm_obj.obj._GetMoId()
vm_dynamic_id = DynamicID(type='VirtualMachine', id=vm_mo_id)
attached_tags = tag_association.list_attached_tags(vm_dynamic_id)
for tag_id in attached_tags:
self.inventory.add_child(tags_info[tag_id], current_host)
cacheable_results[tags_info[tag_id]]['hosts'].append(current_host)
# Based on power state of virtual machine
vm_power = str(vm_obj.obj.summary.runtime.powerState)
if vm_power not in cacheable_results:
cacheable_results[vm_power] = {'hosts': []}
self.inventory.add_group(vm_power)
cacheable_results[vm_power]['hosts'].append(current_host)
self.inventory.add_child(vm_power, current_host)
# Based on guest id
vm_guest_id = vm_obj.obj.config.guestId
if vm_guest_id and vm_guest_id not in cacheable_results:
cacheable_results[vm_guest_id] = {'hosts': []}
self.inventory.add_group(vm_guest_id)
cacheable_results[vm_guest_id]['hosts'].append(current_host)
self.inventory.add_child(vm_guest_id, current_host)
for host in hostvars:
h = self.inventory.get_host(host)
cacheable_results['_meta']['hostvars'][h.name] = h.vars
return cacheable_results
def _populate_host_properties(self, vm_obj, current_host):
# Load VM properties in host_vars
vm_properties = self.get_option('properties') or []
field_mgr = self.pyv.content.customFieldsManager.field
for vm_prop in vm_properties:
if vm_prop == 'customValue':
for cust_value in vm_obj.obj.customValue:
self.inventory.set_variable(current_host,
[y.name for y in field_mgr if y.key == cust_value.key][0],
cust_value.value)
else:
vm_value = self.pyv._get_object_prop(vm_obj.obj, vm_prop.split("."))
self.inventory.set_variable(current_host, vm_prop, vm_value)

1630
test/support/integration/plugins/module_utils/vmware.py
View file

File diff suppressed because it is too large Load diff

2914
test/support/integration/plugins/modules/vmware_guest.py
View file

File diff suppressed because it is too large Load diff

261
test/support/integration/plugins/modules/vmware_host_hyperthreading.py
View file

@ -1,261 +0,0 @@
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright: (c) 2018, Christian Kotte <christian.kotte@gmx.de>
#
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {
'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'community'
}
DOCUMENTATION = r'''
---
module: vmware_host_hyperthreading
short_description: Enables/Disables Hyperthreading optimization for an ESXi host system
description:
- This module can be used to enable or disable Hyperthreading optimization for ESXi host systems in given vCenter infrastructure.
- It also checks if Hyperthreading is activated/deactivated and if the host needs to be restarted.
- The module informs the user if Hyperthreading is enabled but inactive because the processor is vulnerable to L1 Terminal Fault (L1TF).
version_added: 2.8
author:
- Christian Kotte (@ckotte)
notes:
- Tested on vSphere 6.5
requirements:
- python >= 2.6
- PyVmomi
options:
state:
description:
- Enable or disable Hyperthreading.
- You need to reboot the ESXi host if you change the configuration.
- Make sure that Hyperthreading is enabled in the BIOS. Otherwise, it will be enabled, but never activated.
type: str
choices: [ enabled, disabled ]
default: 'enabled'
esxi_hostname:
description:
- Name of the host system to work with.
- This parameter is required if C(cluster_name) is not specified.
type: str
cluster_name:
description:
- Name of the cluster from which all host systems will be used.
- This parameter is required if C(esxi_hostname) is not specified.
type: str
extends_documentation_fragment: vmware.documentation
'''
EXAMPLES = r'''
- name: Enable Hyperthreading for an host system
vmware_host_hyperthreading:
hostname: '{{ vcenter_hostname }}'
username: '{{ vcenter_username }}'
password: '{{ vcenter_password }}'
esxi_hostname: '{{ esxi_hostname }}'
state: enabled
validate_certs: no
delegate_to: localhost
- name: Disable Hyperthreading for an host system
vmware_host_hyperthreading:
hostname: '{{ vcenter_hostname }}'
username: '{{ vcenter_username }}'
password: '{{ vcenter_password }}'
esxi_hostname: '{{ esxi_hostname }}'
state: disabled
validate_certs: no
delegate_to: localhost
- name: Disable Hyperthreading for all host systems from cluster
vmware_host_hyperthreading:
hostname: '{{ vcenter_hostname }}'
username: '{{ vcenter_username }}'
password: '{{ vcenter_password }}'
cluster_name: '{{ cluster_name }}'
state: disabled
validate_certs: no
delegate_to: localhost
'''
RETURN = r'''
results:
description: metadata about host system's Hyperthreading configuration
returned: always
type: dict
sample: {
"esxi01": {
"msg": "Hyperthreading is already enabled and active for host 'esxi01'",
"state_current": "active",
"state": "enabled",
},
}
'''
try:
from pyVmomi import vim, vmodl
except ImportError:
pass
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.vmware import PyVmomi, vmware_argument_spec
from ansible.module_utils._text import to_native
class VmwareHostHyperthreading(PyVmomi):
"""Manage Hyperthreading for an ESXi host system"""
def __init__(self, module):
super(VmwareHostHyperthreading, self).__init__(module)
cluster_name = self.params.get('cluster_name')
esxi_host_name = self.params.get('esxi_hostname')
self.hosts = self.get_all_host_objs(cluster_name=cluster_name, esxi_host_name=esxi_host_name)
if not self.hosts:
self.module.fail_json(msg="Failed to find host system.")
def ensure(self):
"""Manage Hyperthreading for an ESXi host system"""
results = dict(changed=False, result=dict())
desired_state = self.params.get('state')
host_change_list = []
for host in self.hosts:
changed = False
results['result'][host.name] = dict(msg='')
hyperthreading_info = host.config.hyperThread
results['result'][host.name]['state'] = desired_state
if desired_state == 'enabled':
# Don't do anything if Hyperthreading is already enabled
if hyperthreading_info.config:
if hyperthreading_info.active:
results['result'][host.name]['changed'] = False
results['result'][host.name]['state_current'] = "active"
results['result'][host.name]['msg'] = "Hyperthreading is enabled and active"
if not hyperthreading_info.active:
# L1 Terminal Fault (L1TF)/Foreshadow mitigation workaround (https://kb.vmware.com/s/article/55806)
option_manager = host.configManager.advancedOption
try:
mitigation = option_manager.QueryOptions('VMkernel.Boot.hyperthreadingMitigation')
except vim.fault.InvalidName:
mitigation = None
if mitigation and mitigation[0].value:
results['result'][host.name]['changed'] = False
results['result'][host.name]['state_current'] = "enabled"
results['result'][host.name]['msg'] = ("Hyperthreading is enabled, but not active because the"
" processor is vulnerable to L1 Terminal Fault (L1TF).")
else:
changed = results['result'][host.name]['changed'] = True
results['result'][host.name]['state_current'] = "enabled"
results['result'][host.name]['msg'] = ("Hyperthreading is enabled, but not active."
" A reboot is required!")
# Enable Hyperthreading
else:
# Check if Hyperthreading is available
if hyperthreading_info.available:
if not self.module.check_mode:
try:
host.configManager.cpuScheduler.EnableHyperThreading()
changed = results['result'][host.name]['changed'] = True
results['result'][host.name]['state_previous'] = "disabled"
results['result'][host.name]['state_current'] = "enabled"
results['result'][host.name]['msg'] = (
"Hyperthreading enabled for host. Reboot the host to activate it."
)
except vmodl.fault.NotSupported as not_supported:
# This should never happen since Hyperthreading is available
self.module.fail_json(
msg="Failed to enable Hyperthreading for host '%s' : %s" %
(host.name, to_native(not_supported.msg))
)
except (vmodl.RuntimeFault, vmodl.MethodFault) as runtime_fault:
self.module.fail_json(
msg="Failed to enable Hyperthreading for host '%s' due to : %s" %
(host.name, to_native(runtime_fault.msg))
)
else:
changed = results['result'][host.name]['changed'] = True
results['result'][host.name]['state_previous'] = "disabled"
results['result'][host.name]['state_current'] = "enabled"
results['result'][host.name]['msg'] = "Hyperthreading will be enabled"
else:
self.module.fail_json(msg="Hyperthreading optimization is not available for host '%s'" % host.name)
elif desired_state == 'disabled':
# Don't do anything if Hyperthreading is already disabled
if not hyperthreading_info.config:
if not hyperthreading_info.active:
results['result'][host.name]['changed'] = False
results['result'][host.name]['state_current'] = "inactive"
results['result'][host.name]['msg'] = "Hyperthreading is disabled and inactive"
if hyperthreading_info.active:
changed = results['result'][host.name]['changed'] = True
results['result'][host.name]['state_current'] = "disabled"
results['result'][host.name]['msg'] = ("Hyperthreading is already disabled"
" but still active. A reboot is required!")
# Disable Hyperthreading
else:
# Check if Hyperthreading is available
if hyperthreading_info.available:
if not self.module.check_mode:
try:
host.configManager.cpuScheduler.DisableHyperThreading()
changed = results['result'][host.name]['changed'] = True
results['result'][host.name]['state_previous'] = "enabled"
results['result'][host.name]['state_current'] = "disabled"
results['result'][host.name]['msg'] = (
"Hyperthreading disabled. Reboot the host to deactivate it."
)
except vmodl.fault.NotSupported as not_supported:
# This should never happen since Hyperthreading is available
self.module.fail_json(
msg="Failed to disable Hyperthreading for host '%s' : %s" %
(host.name, to_native(not_supported.msg))
)
except (vmodl.RuntimeFault, vmodl.MethodFault) as runtime_fault:
self.module.fail_json(
msg="Failed to disable Hyperthreading for host '%s' due to : %s" %
(host.name, to_native(runtime_fault.msg))
)
else:
changed = results['result'][host.name]['changed'] = True
results['result'][host.name]['state_previous'] = "enabled"
results['result'][host.name]['state_current'] = "disabled"
results['result'][host.name]['msg'] = "Hyperthreading will be disabled"
else:
self.module.fail_json(msg="Hyperthreading optimization is not available for host '%s'" % host.name)
host_change_list.append(changed)
if any(host_change_list):
results['changed'] = True
self.module.exit_json(**results)
def main():
"""Main"""
argument_spec = vmware_argument_spec()
argument_spec.update(
state=dict(default='enabled', choices=['enabled', 'disabled']),
esxi_hostname=dict(type='str', required=False),
cluster_name=dict(type='str', required=False),
)
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=[
['cluster_name', 'esxi_hostname'],
],
supports_check_mode=True
)
hyperthreading = VmwareHostHyperthreading(module)
hyperthreading.ensure()
if __name__ == '__main__':
main()