def main():
"""Main"""
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(
esxi_hostname=dict(required=True, type='str'),
portgroup_name=dict(required=True,
type='str',
aliases=['portgroup']),
mtu=dict(required=False, type='int', default=1500),
device=dict(type='str'),
enable_vsan=dict(required=False, type='bool', default=False),
enable_vmotion=dict(required=False, type='bool', default=False),
enable_mgmt=dict(required=False, type='bool', default=False),
enable_ft=dict(required=False, type='bool', default=False),
enable_provisioning=dict(type='bool', default=False),
enable_replication=dict(type='bool', default=False),
enable_replication_nfc=dict(type='bool', default=False),
vswitch_name=dict(required=False, type='str', aliases=['vswitch']),
dvswitch_name=dict(required=False,
type='str',
aliases=['dvswitch']),
network=dict(
type='dict',
options=dict(
type=dict(type='str',
default='static',
choices=['static', 'dhcp']),
ip_address=dict(type='str'),
subnet_mask=dict(type='str'),
default_gateway=dict(type='str'),
tcpip_stack=dict(type='str',
default='default',
choices=[
'default', 'provisioning', 'vmotion',
'vxlan'
]),
),
default=dict(
type='static',
tcpip_stack='default',
),
),
state=dict(type='str',
default='present',
choices=['absent', 'present']),
))
module = AnsibleModule(
argument_spec=argument_spec,
mutually_exclusive=[
['vswitch_name', 'dvswitch_name'],
['tcpip_stack', 'enable_vsan'],
['tcpip_stack', 'enable_vmotion'],
['tcpip_stack', 'enable_mgmt'],
['tcpip_stack', 'enable_ft'],
['tcpip_stack', 'enable_provisioning'],
['tcpip_stack', 'enable_replication'],
['tcpip_stack', 'enable_replication_nfc'],
],
required_one_of=[
['vswitch_name', 'dvswitch_name'],
['portgroup_name', 'device'],
],
required_if=[['state', 'present', ['portgroup_name']],
['state', 'absent', ['device']]],
supports_check_mode=True)
pyv = PyVmomiHelper(module)
pyv.ensure()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(name=dict(type='str'),
uuid=dict(type='str'),
use_instance_uuid=dict(type='bool', default=False),
moid=dict(type='str'),
folder=dict(type='str'),
datacenter=dict(type='str', default='ha-datacenter'),
esxi_hostname=dict(type='str'),
cluster=dict(type='str'),
mac_address=dict(type='str'),
vlan_id=dict(type='int'),
network_name=dict(type='str'),
device_type=dict(type='str', default='vmxnet3'),
label=dict(type='str'),
switch=dict(type='str'),
connected=dict(type='bool', default=True),
start_connected=dict(type='bool', default=True),
wake_onlan=dict(type='bool', default=False),
directpath_io=dict(type='bool', default=False),
force=dict(type='bool', default=False),
gather_network_info=dict(
type='bool',
default=False,
aliases=['gather_network_facts']),
networks=dict(type='list', default=[]),
guest_control=dict(type='bool', default=True),
state=dict(type='str',
default='present',
choices=['absent', 'present']))
module = AnsibleModule(argument_spec=argument_spec,
mutually_exclusive=[['vlan_id', 'network_name']],
required_one_of=[['name', 'uuid', 'moid']],
supports_check_mode=True)
pyv = PyVmomiHelper(module)
if module.params['gather_network_info']:
nics = pyv._get_nic_info()
network_data = {}
nics_sorted = sorted(nics.get('network_info'),
key=lambda k: k['unit_number'])
for n, i in enumerate(nics_sorted):
key_name = '{0}'.format(n)
network_data[key_name] = i
network_data[key_name].update({
'mac_addr': i['mac_address'],
'name': i['network_name']
})
module.exit_json(network_info=nics.get('network_info'),
network_data=network_data,
changed=False)
if module.params['networks']:
network_data = {}
module.deprecate(
'The old way of configuring interfaces by supplying an arbitrary list will be removed, loops should be used to handle multiple interfaces',
'2.11')
diff, changed, network_info = pyv._deprectated_list_config()
nd = copy.deepcopy(network_info)
nics_sorted = sorted(nd, key=lambda k: k['unit_number'])
for n, i in enumerate(nics_sorted):
key_name = '{0}'.format(n)
network_data[key_name] = i
network_data[key_name].update({
'mac_addr': i['mac_address'],
'name': i['network_name']
})
module.exit_json(changed=changed,
network_info=network_info,
network_data=network_data,
diff=diff)
if module.params['state'] == 'present':
diff, changed, network_info = pyv._nic_present()
if module.params['state'] == 'absent':
if not module.params['mac_address']:
module.fail_json(
msg='parameter mac_address required when removing nics')
diff, changed, network_info = pyv._nic_absent()
module.exit_json(changed=changed, network_info=network_info, diff=diff)
def main():
"""
Main method
"""
argument_spec = vmware_argument_spec()
argument_spec.update(
name=dict(type='str'),
uuid=dict(type='str'),
moid=dict(type='str'),
use_instance_uuid=dict(type='bool', default=False),
backings=dict(
type='list',
elements='dict',
required=True,
options=dict(backing_type=dict(type='str',
required=True,
aliases=['type']),
pipe_name=dict(type='str', default=None),
endpoint=dict(type='str',
choices=['client', 'server'],
default='client'),
no_rx_loss=dict(type='bool', default=False),
service_uri=dict(type='str', default=None),
direction=dict(type='str',
choices=['client', 'server'],
default='client'),
device_name=dict(type='str', default=None),
file_path=dict(type='str', default=None),
yield_on_poll=dict(type='bool', default=True),
state=dict(type='str',
choices=['present', 'absent'],
default='present')),
required_if=[[
'backing_type', 'pipe',
['pipe_name', 'endpoint', 'no_rx_loss']
], ['backing_type', 'network', ['service_uri', 'direction']],
['backing_type', 'device', ['device_name']],
['backing_type', 'file', ['file_path']]]),
)
module = AnsibleModule(
argument_spec=argument_spec,
required_one_of=[['name', 'uuid', 'moid']],
mutually_exclusive=[['name', 'uuid', 'moid']],
)
result = {'failed': False, 'changed': False}
pyv = PyVmomiHelper(module)
# Check if the VM exists before continuing
vm_obj = pyv.get_vm()
if vm_obj:
proceed = pyv.check_vm_state(vm_obj)
if proceed:
result = pyv.reconfigure_vm_serial_port(vm_obj)
else:
# We are unable to find the virtual machine user specified
# Bail out
vm_id = (module.params.get('name') or module.params.get('uuid')
or module.params.get('vm_id'))
module.fail_json(msg="Unable to manage serial ports for non-existing"
" virtual machine '%s'." % vm_id)
if result['failed']:
module.fail_json(**result)
else:
module.exit_json(**result)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(
extension_key=dict(type='str', required=True),
version=dict(type='str', required=True),
email=dict(type='str', required=False),
description=dict(type='str', required=False),
company=dict(type='str', required=False),
name=dict(type='str', required=False),
url=dict(type='str', required=False),
ssl_thumbprint=dict(type='str', required=False),
client_type=dict(type='str',
default='vsphere-client-serenity',
required=False),
server_type=dict(type='str',
default='vsphere-client-serenity',
required=False),
visible=dict(type='bool', default='True', required=False),
state=dict(type='str',
default='present',
choices=['absent', 'present']),
))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False,
required_if=[[
'state', 'present',
[
'email', 'description', 'company', 'name',
'url', 'ssl_thumbprint', 'server_type',
'client_type'
]
]])
state = module.params['state']
extension_key = module.params['extension_key']
version = module.params['version']
email = module.params['email']
desc = module.params['description']
name = module.params['name']
company = module.params['company']
client_type = module.params['client_type']
server_type = module.params['server_type']
url = module.params['url']
visible = module.params['visible']
thumbprint = module.params['ssl_thumbprint']
content = connect_to_api(module, False)
em = content.extensionManager
key_check = em.FindExtension(extension_key)
results = dict(changed=False, installed=dict())
if state == 'present' and key_check:
results['changed'] = False
results['installed'] = "'%s' is already installed" % (extension_key)
elif state == 'present' and not key_check:
extension = vim.Extension()
extension.key = extension_key
extension.company = company
extension.version = version
extension.lastHeartbeatTime = datetime.datetime.now()
description = vim.Description()
description.label = name
description.summary = desc
extension.description = description
extension.shownInSolutionManager = visible
client = vim.Extension.ClientInfo()
client.company = company
client.version = version
client.description = description
client.type = client_type
client.url = url
extension.client = [client]
server = vim.Extension.ServerInfo()
server.company = company
server.description = description
server.type = server_type
server.adminEmail = email
server.serverThumbprint = thumbprint
server.url = url
extension.server = [server]
em.RegisterExtension(extension)
results['changed'] = True
results['installed'] = "'%s' installed." % (extension_key)
elif state == 'absent' and key_check:
em.UnregisterExtension(extension_key)
results['changed'] = True
results['installed'] = "'%s' uninstalled." % (extension_key)
elif state == 'absent' and not key_check:
results['changed'] = False
results['installed'] = "'%s' is not installed." % (extension_key)
module.exit_json(**results)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
name=dict(type='str'),
uuid=dict(type='str'),
moid=dict(type='str'),
folder=dict(type='str'),
datacenter=dict(type='str', default='ha-datacenter'),
controllers=dict(
type='list',
elements='dict',
required=False,
options=dict(
state=dict(type='str',
choices=['present', 'absent'],
required=True),
controller_number=dict(type='int',
choices=[0, 1, 2, 3],
required=False),
type=dict(
type='str',
choices=[
'sata', 'nvme', 'lsilogic', 'buslogic', 'lsilogicsas',
'paravirtual', 'usb2', 'usb3'
],
required=True,
),
),
),
use_instance_uuid=dict(type='bool', default=False),
gather_disk_controller_facts=dict(type='bool', default=False),
sleep_time=dict(type='int', default=10),
)
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=[['name', 'uuid', 'moid']])
if module.params['folder']:
# FindByInventoryPath() does not require an absolute path
# so we should leave the input folder path unmodified
module.params['folder'] = module.params['folder'].rstrip('/')
pyv = PyVmomiHelper(module)
# Check if the VM exists before continuing
vm = pyv.get_vm()
if not vm:
# We unable to find the virtual machine user specified
# Bail out
vm_id = (module.params.get('name') or module.params.get('uuid')
or module.params.get('moid'))
module.fail_json(
msg=
"Unable to manage disk or USB controllers for non-existing virtual machine '%s'."
% vm_id)
# VM exists
result = pyv.configure_disk_controllers()
if result['failed']:
module.fail_json(**result)
else:
module.exit_json(**result)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update({
'name': {},
'datastore': {
'default': 'datastore1',
},
'datacenter': {
'default': 'ha-datacenter',
},
'cluster': {
'default': None,
},
'deployment_option': {
'default': None,
},
'folder': {
'default': None,
},
'inject_ovf_env': {
'default': False,
'type': 'bool',
},
'resource_pool': {
'default': 'Resources',
},
'networks': {
'default': {
'VM Network': 'VM Network',
},
'type': 'dict',
},
'ovf': {
'type': 'path',
'aliases': ['ova'],
},
'disk_provisioning': {
'choices': [
'flat', 'eagerZeroedThick', 'monolithicSparse',
'twoGbMaxExtentSparse', 'twoGbMaxExtentFlat', 'thin', 'sparse',
'thick', 'seSparse', 'monolithicFlat'
],
'default':
'thin',
},
'power_on': {
'type': 'bool',
'default': True,
},
'properties': {
'type': 'dict',
},
'wait': {
'type': 'bool',
'default': True,
},
'wait_for_ip_address': {
'type': 'bool',
'default': False,
},
'allow_duplicates': {
'type': 'bool',
'default': True,
},
'fail_on_spec_warnings': {
'type': 'bool',
'default': False,
},
})
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
deploy_ovf = VMwareDeployOvf(module)
deploy_ovf.vm_existence_check()
deploy_ovf.upload()
deploy_ovf.complete()
if module.params['inject_ovf_env']:
deploy_ovf.inject_ovf_env()
facts = deploy_ovf.deploy()
facts.update(changed=True)
module.exit_json(**facts)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(dict(
hostname=dict(required=False, aliases=['host']),
username=dict(required=False, aliases=['login']),
src=dict(required=True, aliases=['name']),
datacenter=dict(required=False),
datastore=dict(required=True),
dest=dict(required=True, aliases=['path']),
timeout=dict(default=10, type='int'))
)
module = AnsibleModule(
argument_spec=argument_spec,
# Implementing check-mode using HEAD is impossible, since size/date is not 100% reliable
supports_check_mode=False,
)
if module.params.get('host'):
module.deprecate("The 'host' option is being replaced by 'hostname'", version='2.0.0', collection_name='community.vmware')
if module.params.get('login'):
module.deprecate("The 'login' option is being replaced by 'username'", version='2.0.0', collection_name='community.vmware')
hostname = module.params['hostname']
username = module.params['username']
password = module.params.get('password')
src = module.params.get('src')
datacenter = module.params.get('datacenter')
datastore = module.params.get('datastore')
dest = module.params.get('dest')
validate_certs = module.params.get('validate_certs')
timeout = module.params.get('timeout')
try:
fd = open(src, "rb")
atexit.register(fd.close)
except Exception as e:
module.fail_json(msg="Failed to open src file %s" % to_native(e))
if os.stat(src).st_size == 0:
data = ''
else:
data = mmap.mmap(fd.fileno(), 0, access=mmap.ACCESS_READ)
atexit.register(data.close)
remote_path = vmware_path(datastore, datacenter, dest)
if not all([hostname, username, password]):
module.fail_json(msg="One of following parameter is missing - hostname, username, password")
url = 'https://%s%s' % (hostname, remote_path)
headers = {
"Content-Type": "application/octet-stream",
"Content-Length": str(len(data)),
}
try:
r = open_url(url, data=data, headers=headers, method='PUT', timeout=timeout,
url_username=username, url_password=password, validate_certs=validate_certs,
force_basic_auth=True)
except socket.error as e:
if isinstance(e.args, tuple):
if len(e.args) > 0:
if e[0] == errno.ECONNRESET:
# vSphere resets connection if the file is in use and cannot be replaced
module.fail_json(msg='Failed to upload, image probably in use', status=None, errno=e[0], reason=to_native(e), url=url)
else:
module.fail_json(msg=to_native(e))
else:
module.fail_json(msg=str(e), status=None, errno=e[0], reason=str(e),
url=url, exception=traceback.format_exc())
except Exception as e:
error_code = -1
try:
if isinstance(e[0], int):
error_code = e[0]
except (KeyError, TypeError):
pass
module.fail_json(msg=to_native(e), status=None, errno=error_code,
reason=to_native(e), url=url, exception=traceback.format_exc())
status = r.getcode()
if 200 <= status < 300:
module.exit_json(changed=True, status=status, reason=r.msg, url=url)
else:
length = r.headers.get('content-length', None)
if r.headers.get('transfer-encoding', '').lower() == 'chunked':
chunked = 1
else:
chunked = 0
module.fail_json(msg='Failed to upload', errno=None, status=status, reason=r.msg, length=length, headers=dict(r.headers), chunked=chunked, url=url)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(portgroup_name=dict(required=True, type='str'),
switch_name=dict(required=True, type='str'),
vlan_id=dict(required=True, type='str'),
num_ports=dict(type='int'),
port_binding=dict(required=True,
type='str',
choices=['static', 'ephemeral']),
port_allocation=dict(type='str', choices=['fixed', 'elastic']),
state=dict(required=True,
choices=['present', 'absent'],
type='str'),
vlan_trunk=dict(type='bool', default=False),
vlan_private=dict(type='bool', default=False),
network_policy=dict(type='dict',
options=dict(promiscuous=dict(type='bool',
default=False),
forged_transmits=dict(
type='bool', default=False),
mac_changes=dict(type='bool',
default=False)),
default=dict(promiscuous=False,
forged_transmits=False,
mac_changes=False)),
in_traffic_shaping=dict(
type='dict',
options=dict(
enabled=dict(type='bool'),
average_bandwidth=dict(type='int'),
peak_bandwidth=dict(type='int'),
burst_size=dict(type='int'),
),
),
out_traffic_shaping=dict(
type='dict',
options=dict(
enabled=dict(type='bool'),
average_bandwidth=dict(type='int'),
peak_bandwidth=dict(type='int'),
burst_size=dict(type='int'),
),
),
net_flow=dict(type='bool'),
teaming_policy=dict(
type='dict',
options=dict(
inbound_policy=dict(type='bool'),
notify_switches=dict(type='bool', default=True),
rolling_order=dict(type='bool', default=False),
load_balance_policy=dict(
type='str',
default='loadbalance_srcid',
choices=[
'loadbalance_ip',
'loadbalance_srcmac',
'loadbalance_srcid',
'loadbalance_loadbased',
'failover_explicit',
],
),
active_uplinks=dict(type='list', elements='str'),
standby_uplinks=dict(type='list', elements='str'),
),
default=dict(
notify_switches=True,
rolling_order=False,
load_balance_policy='loadbalance_srcid',
),
),
port_policy=dict(
type='dict',
options=dict(
block_override=dict(type='bool', default=True),
ipfix_override=dict(type='bool', default=False),
live_port_move=dict(type='bool', default=False),
network_rp_override=dict(type='bool', default=False),
port_config_reset_at_disconnect=dict(type='bool',
default=True),
security_override=dict(type='bool', default=False),
shaping_override=dict(type='bool', default=False),
traffic_filter_override=dict(type='bool', default=False),
uplink_teaming_override=dict(type='bool', default=False),
vendor_config_override=dict(type='bool', default=False),
vlan_override=dict(type='bool', default=False)),
default=dict(block_override=True,
ipfix_override=False,
live_port_move=False,
network_rp_override=False,
port_config_reset_at_disconnect=True,
security_override=False,
shaping_override=False,
traffic_filter_override=False,
uplink_teaming_override=False,
vendor_config_override=False,
vlan_override=False),
),
mac_learning=dict(
type='dict',
options=dict(
allow_unicast_flooding=dict(type='bool'),
enabled=dict(type='bool'),
limit=dict(type='int'),
limit_policy=dict(type='str', choices=['allow', 'drop']),
),
)))
module = AnsibleModule(argument_spec=argument_spec,
mutually_exclusive=[
['vlan_trunk', 'vlan_private'],
],
supports_check_mode=True)
vmware_dvs_portgroup = VMwareDvsPortgroup(module)
vmware_dvs_portgroup.process_state()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(dict(
labels=dict(type='dict', default=dict(source='ansible')),
license=dict(type='str', required=True),
state=dict(type='str', default='present', choices=['absent', 'present']),
esxi_hostname=dict(type='str'),
datacenter=dict(type='str'),
cluster_name=dict(type='str'),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
license = module.params['license']
state = module.params['state']
# FIXME: This does not seem to work on vCenter v6.0
labels = []
for k in module.params['labels']:
kv = vim.KeyValue()
kv.key = k
kv.value = module.params['labels'][k]
labels.append(kv)
result = dict(
changed=False,
diff=dict(),
)
pyv = VcenterLicenseMgr(module)
if not pyv.is_vcenter():
module.fail_json(msg="vcenter_license is meant for vCenter, hostname %s "
"is not vCenter server." % module.params.get('hostname'))
lm = pyv.content.licenseManager
result['licenses'] = pyv.list_keys(lm.licenses)
if module._diff:
result['diff']['before'] = '\n'.join(result['licenses']) + '\n'
if state == 'present':
if license not in result['licenses']:
result['changed'] = True
if module.check_mode:
result['licenses'].append(license)
else:
lm.AddLicense(license, labels)
key = pyv.find_key(lm.licenses, license)
if key is not None:
lam = lm.licenseAssignmentManager
assigned_license = None
datacenter = module.params['datacenter']
datacenter_obj = None
if datacenter:
datacenter_obj = pyv.find_datacenter_by_name(datacenter)
if not datacenter_obj:
module.fail_json(msg="Unable to find the datacenter %(datacenter)s" % module.params)
cluster = module.params['cluster_name']
if cluster:
cluster_obj = pyv.find_cluster_by_name(cluster_name=cluster, datacenter_name=datacenter_obj)
if not cluster_obj:
msg = "Unable to find the cluster %(cluster_name)s"
if datacenter:
msg += " in datacenter %(datacenter)s"
module.fail_json(msg=msg % module.params)
entityId = cluster_obj._moId
# assign to current vCenter, if esxi_hostname is not specified
elif module.params['esxi_hostname'] is None:
entityId = pyv.content.about.instanceUuid
# if key name not contain "VMware vCenter Server"
if pyv.content.about.name not in key.name:
module.warn('License key "%s" (%s) is not suitable for "%s"' % (license, key.name, pyv.content.about.name))
# assign to ESXi server
else:
esxi_host = find_hostsystem_by_name(pyv.content, module.params['esxi_hostname'])
if esxi_host is None:
module.fail_json(msg='Cannot find the specified ESXi host "%s".' % module.params['esxi_hostname'])
entityId = esxi_host._moId
# e.g., key.editionKey is "esx.enterprisePlus.cpuPackage", not sure all keys are in this format
if 'esx' not in key.editionKey:
module.warn('License key "%s" edition "%s" is not suitable for ESXi server' % (license, key.editionKey))
try:
assigned_license = lam.QueryAssignedLicenses(entityId=entityId)
except Exception as e:
module.fail_json(msg='Could not query vCenter "%s" assigned license info due to %s.' % (entityId, to_native(e)))
if not assigned_license or (len(assigned_license) != 0 and assigned_license[0].assignedLicense.licenseKey != license):
try:
lam.UpdateAssignedLicense(entity=entityId, licenseKey=license)
except Exception:
module.fail_json(msg='Could not assign "%s" (%s) to vCenter.' % (license, key.name))
result['changed'] = True
result['licenses'] = pyv.list_keys(lm.licenses)
else:
module.fail_json(msg='License "%s" is not existing or can not be added' % license)
if module._diff:
result['diff']['after'] = '\n'.join(result['licenses']) + '\n'
elif state == 'absent' and license in result['licenses']:
# Check if key is in use
key = pyv.find_key(lm.licenses, license)
if key.used > 0:
module.fail_json(msg='Cannot remove key "%s", still in use %s time(s).' % (license, key.used))
result['changed'] = True
if module.check_mode:
result['licenses'].remove(license)
else:
lm.RemoveLicense(license)
result['licenses'] = pyv.list_keys(lm.licenses)
if module._diff:
result['diff']['after'] = '\n'.join(result['licenses']) + '\n'
module.exit_json(**result)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(
cluster_name=dict(type='str', required=True),
datacenter=dict(type='str',
required=True,
aliases=['datacenter_name']),
state=dict(type='str',
default='present',
choices=['absent', 'present']),
# DRS
ignore_drs=dict(type='bool', default=False),
enable_drs=dict(type='bool',
removed_from_collection='ansible.builtin',
removed_in_version='2.12',
default=False),
drs_enable_vm_behavior_overrides=dict(
type='bool',
removed_from_collection='ansible.builtin',
removed_in_version='2.12',
default=True),
drs_default_vm_behavior=dict(
type='str',
removed_from_collection='ansible.builtin',
removed_in_version='2.12',
choices=['fullyAutomated', 'manual', 'partiallyAutomated'],
default='fullyAutomated'),
drs_vmotion_rate=dict(type='int',
removed_from_collection='ansible.builtin',
removed_in_version='2.12',
choices=[1, 2, 3, 4, 5],
default=3),
# HA
ignore_ha=dict(type='bool', default=False),
enable_ha=dict(type='bool',
default=False,
removed_from_collection='ansible.builtin',
removed_in_version='2.12'),
ha_failover_level=dict(type='int',
default=2,
removed_from_collection='ansible.builtin',
removed_in_version='2.12'),
ha_host_monitoring=dict(type='str',
removed_in_version='2.12',
removed_from_collection='ansible.builtin',
default='enabled',
choices=['enabled', 'disabled']),
# HA VM Monitoring related parameters
ha_vm_monitoring=dict(type='str',
removed_in_version='2.12',
removed_from_collection='ansible.builtin',
choices=[
'vmAndAppMonitoring', 'vmMonitoringOnly',
'vmMonitoringDisabled'
],
default='vmMonitoringDisabled'),
ha_vm_failure_interval=dict(
type='int',
default=30,
removed_from_collection='ansible.builtin',
removed_in_version='2.12'),
ha_vm_min_up_time=dict(type='int',
default=120,
removed_from_collection='ansible.builtin',
removed_in_version='2.12'),
ha_vm_max_failures=dict(type='int',
default=3,
removed_from_collection='ansible.builtin',
removed_in_version='2.12'),
ha_vm_max_failure_window=dict(
type='int',
default=-1,
removed_from_collection='ansible.builtin',
removed_in_version='2.12'),
ha_restart_priority=dict(
type='str',
removed_in_version='2.12',
removed_from_collection='ansible.builtin',
choices=['high', 'low', 'medium', 'disabled'],
default='medium'),
ha_admission_control_enabled=dict(
type='bool',
default=True,
removed_in_version='2.12',
removed_from_collection='ansible.builtin'),
# VSAN
ignore_vsan=dict(type='bool', default=False),
enable_vsan=dict(type='bool',
default=False,
removed_in_version='2.12',
removed_from_collection='ansible.builtin'),
vsan_auto_claim_storage=dict(
type='bool',
default=False,
removed_in_version='2.12',
removed_from_collection='ansible.builtin'),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
vmware_cluster = VMwareCluster(module)
vmware_cluster.process_state()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(
cluster_name=dict(type='str', required=True),
datacenter=dict(type='str',
required=True,
aliases=['datacenter_name']),
# HA
enable_ha=dict(type='bool', default=False),
ha_host_monitoring=dict(type='str',
default='enabled',
choices=['enabled', 'disabled']),
host_isolation_response=dict(
type='str',
default='none',
choices=['none', 'powerOff', 'shutdown']),
advanced_settings=dict(type='dict', default=dict(),
required=False),
# HA VM Monitoring related parameters
ha_vm_monitoring=dict(type='str',
choices=[
'vmAndAppMonitoring', 'vmMonitoringOnly',
'vmMonitoringDisabled'
],
default='vmMonitoringDisabled'),
ha_vm_failure_interval=dict(type='int', default=30),
ha_vm_min_up_time=dict(type='int', default=120),
ha_vm_max_failures=dict(type='int', default=3),
ha_vm_max_failure_window=dict(type='int', default=-1),
ha_restart_priority=dict(
type='str',
choices=['high', 'low', 'medium', 'disabled'],
default='medium'),
# HA Admission Control related parameters
slot_based_admission_control=dict(
type='dict',
options=dict(failover_level=dict(type='int',
required=True), )),
reservation_based_admission_control=dict(
type='dict',
options=dict(
auto_compute_percentages=dict(type='bool', default=True),
failover_level=dict(type='int', required=True),
cpu_failover_resources_percent=dict(type='int',
default=50),
memory_failover_resources_percent=dict(type='int',
default=50),
)),
failover_host_admission_control=dict(
type='dict',
options=dict(failover_hosts=dict(type='list',
elements='str',
required=True), )),
))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True,
mutually_exclusive=[[
'slot_based_admission_control',
'reservation_based_admission_control',
'failover_host_admission_control'
]])
vmware_cluster_ha = VMwareCluster(module)
vmware_cluster_ha.configure_ha()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(name=dict(type='str'),
name_match=dict(type='str',
choices=['first', 'last'],
default='first'),
uuid=dict(type='str'),
use_instance_uuid=dict(type='bool', default=False),
moid=dict(type='str'),
folder=dict(type='str'),
datacenter=dict(type='str', required=True),
tags=dict(type='bool', default=False),
schema=dict(type='str',
choices=['summary', 'vsphere'],
default='summary'),
properties=dict(type='list'))
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=[['name', 'uuid', 'moid']],
supports_check_mode=True)
if module._name == 'vmware_guest_facts':
module.deprecate(
"The 'vmware_guest_facts' module has been renamed to 'vmware_guest_info'",
version='2.13')
if module.params.get('folder'):
# FindByInventoryPath() does not require an absolute path
# so we should leave the input folder path unmodified
module.params['folder'] = module.params['folder'].rstrip('/')
if module.params['schema'] != 'vsphere' and module.params.get(
'properties'):
module.fail_json(
msg=
"The option 'properties' is only valid when the schema is 'vsphere'"
)
pyv = PyVmomi(module)
# Check if the VM exists before continuing
vm = pyv.get_vm()
# VM already exists
if vm:
try:
if module.params['schema'] == 'summary':
instance = pyv.gather_facts(vm)
else:
instance = pyv.to_json(vm, module.params['properties'])
if module.params.get('tags'):
if not HAS_VSPHERE:
module.fail_json(
msg=
"Unable to find 'vCloud Suite SDK' Python library which is required."
" Please refer this URL for installation steps"
" - https://code.vmware.com/web/sdk/60/vcloudsuite-python"
)
vm_rest_client = VmwareTag(module)
instance.update(tags=vm_rest_client.get_vm_tags(
vm_rest_client.tag_service,
vm_rest_client.tag_association_svc,
vm_mid=vm._moId))
module.exit_json(instance=instance)
except Exception as exc:
module.fail_json(
msg="Information gathering failed with exception %s" %
to_text(exc))
else:
vm_id = (module.params.get('uuid') or module.params.get('name')
or module.params.get('moid'))
module.fail_json(
msg="Unable to gather information for non-existing VM %s" % vm_id)
def main():
"""Main"""
argument_spec = vmware_argument_spec()
argument_spec.update(
database=dict(
type='dict',
options=dict(
max_connections=dict(type='int', default=50),
task_cleanup=dict(type='bool', default=True),
task_retention=dict(type='int', default=30),
event_cleanup=dict(type='bool', default=True),
event_retention=dict(type='int', default=30),
),
default=dict(
max_connections=50,
task_cleanup=True,
task_retention=30,
event_cleanup=True,
event_retention=30,
),
),
runtime_settings=dict(
type='dict',
options=dict(
unique_id=dict(type='int'),
managed_address=dict(type='str'),
vcenter_server_name=dict(type='str'),
),
),
user_directory=dict(
type='dict',
options=dict(
timeout=dict(type='int', default=60),
query_limit=dict(type='bool', default=True),
query_limit_size=dict(type='int', default=5000),
validation=dict(type='bool', default=True),
validation_period=dict(type='int', default=1440),
),
default=dict(
timeout=60,
query_limit=True,
query_limit_size=5000,
validation=True,
validation_period=1440,
),
),
mail=dict(
type='dict',
options=dict(
server=dict(type='str'),
sender=dict(type='str'),
),
default=dict(
server='',
sender='',
),
),
snmp_receivers=dict(
type='dict',
options=dict(
snmp_receiver_1_url=dict(type='str', default='localhost'),
snmp_receiver_1_enabled=dict(type='bool', default=True),
snmp_receiver_1_port=dict(type='int', default=162),
snmp_receiver_1_community=dict(type='str', default='public'),
snmp_receiver_2_url=dict(type='str', default=''),
snmp_receiver_2_enabled=dict(type='bool', default=False),
snmp_receiver_2_port=dict(type='int', default=162),
snmp_receiver_2_community=dict(type='str', default=''),
snmp_receiver_3_url=dict(type='str', default=''),
snmp_receiver_3_enabled=dict(type='bool', default=False),
snmp_receiver_3_port=dict(type='int', default=162),
snmp_receiver_3_community=dict(type='str', default=''),
snmp_receiver_4_url=dict(type='str', default=''),
snmp_receiver_4_enabled=dict(type='bool', default=False),
snmp_receiver_4_port=dict(type='int', default=162),
snmp_receiver_4_community=dict(type='str', default=''),
),
default=dict(
snmp_receiver_1_url='localhost',
snmp_receiver_1_enabled=True,
snmp_receiver_1_port=162,
snmp_receiver_1_community='public',
snmp_receiver_2_url='',
snmp_receiver_2_enabled=False,
snmp_receiver_2_port=162,
snmp_receiver_2_community='',
snmp_receiver_3_url='',
snmp_receiver_3_enabled=False,
snmp_receiver_3_port=162,
snmp_receiver_3_community='',
snmp_receiver_4_url='',
snmp_receiver_4_enabled=False,
snmp_receiver_4_port=162,
snmp_receiver_4_community='',
),
),
timeout_settings=dict(
type='dict',
options=dict(
normal_operations=dict(type='int', default=30),
long_operations=dict(type='int', default=120),
),
default=dict(
normal_operations=30,
long_operations=120,
),
),
logging_options=dict(
default='info',
choices=['none', 'error', 'warning', 'info', 'verbose', 'trivia']),
)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
host_snmp = VmwareVcenterSettings(module)
host_snmp.ensure()
def main():
"""Main"""
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(
portgroup=dict(type='str',
required=True,
aliases=['portgroup_name']),
switch=dict(type='str',
required=True,
aliases=['switch_name', 'vswitch']),
vlan_id=dict(type='int',
required=False,
default=0,
aliases=['vlan']),
hosts=dict(type='list', aliases=['esxi_hostname'], elements='str'),
cluster_name=dict(type='str', aliases=['cluster']),
state=dict(type='str',
choices=['present', 'absent'],
default='present'),
security=dict(type='dict',
options=dict(
promiscuous_mode=dict(type='bool'),
forged_transmits=dict(type='bool'),
mac_changes=dict(type='bool'),
),
aliases=['security_policy', 'network_policy']),
traffic_shaping=dict(
type='dict',
options=dict(
enabled=dict(type='bool'),
average_bandwidth=dict(type='int'),
peak_bandwidth=dict(type='int'),
burst_size=dict(type='int'),
),
),
teaming=dict(
type='dict',
options=dict(
load_balancing=dict(
type='str',
choices=[
None,
'loadbalance_ip',
'loadbalance_srcmac',
'loadbalance_srcid',
'failover_explicit',
],
aliases=['load_balance_policy'],
),
network_failure_detection=dict(
type='str',
choices=['link_status_only', 'beacon_probing']),
notify_switches=dict(type='bool'),
failback=dict(type='bool'),
active_adapters=dict(type='list', elements='str'),
standby_adapters=dict(type='list', elements='str'),
),
aliases=['teaming_policy']),
))
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=[
['cluster_name', 'hosts'],
],
supports_check_mode=True)
try:
host_portgroup = VMwareHostPortGroup(module)
host_portgroup.process_state()
except vmodl.RuntimeFault as runtime_fault:
module.fail_json(msg=to_native(runtime_fault.msg))
except vmodl.MethodFault as method_fault:
module.fail_json(msg=to_native(method_fault.msg))
except Exception as e:
module.fail_json(msg=to_native(e))
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
datacenter=dict(type='str', default='ha-datacenter'),
state=dict(type='str',
default='present',
choices=[
'present', 'powered-off', 'powered-on', 'reboot-guest',
'restarted', 'shutdown-guest', 'suspended'
]),
name=dict(type='str'),
name_match=dict(type='str', choices=['first', 'last'],
default='first'),
uuid=dict(type='str'),
moid=dict(type='str'),
use_instance_uuid=dict(type='bool', default=False),
folder=dict(type='str'),
force=dict(type='bool', default=False),
scheduled_at=dict(type='str'),
schedule_task_name=dict(),
schedule_task_description=dict(),
schedule_task_enabled=dict(type='bool', default=True),
state_change_timeout=dict(type='int', default=0),
answer=dict(type='list',
elements='dict',
options=dict(question=dict(type='str', required=True),
response=dict(type='str', required=True))))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False,
mutually_exclusive=[['name', 'uuid', 'moid'],
['scheduled_at', 'answer']],
)
result = dict(changed=False, )
pyv = PyVmomi(module)
# Check if the VM exists before continuing
vm = pyv.get_vm()
if vm:
# VM already exists, so set power state
scheduled_at = module.params.get('scheduled_at', None)
if scheduled_at:
if not pyv.is_vcenter():
module.fail_json(
msg="Scheduling task requires vCenter, hostname %s "
"is an ESXi server." % module.params.get('hostname'))
powerstate = {
'present': vim.VirtualMachine.PowerOn,
'powered-off': vim.VirtualMachine.PowerOff,
'powered-on': vim.VirtualMachine.PowerOn,
'reboot-guest': vim.VirtualMachine.RebootGuest,
'restarted': vim.VirtualMachine.Reset,
'shutdown-guest': vim.VirtualMachine.ShutdownGuest,
'suspended': vim.VirtualMachine.Suspend,
}
dt = ''
try:
dt = datetime.strptime(scheduled_at, '%d/%m/%Y %H:%M')
except ValueError as e:
module.fail_json(
msg=
"Failed to convert given date and time string to Python datetime object,"
"please specify string in 'dd/mm/yyyy hh:mm' format: %s" %
to_native(e))
schedule_task_spec = vim.scheduler.ScheduledTaskSpec()
schedule_task_name = module.params[
'schedule_task_name'] or 'task_%s' % str(randint(10000, 99999))
schedule_task_desc = module.params['schedule_task_description']
if schedule_task_desc is None:
schedule_task_desc = 'Schedule task for vm %s for ' \
'operation %s at %s' % (vm.name, module.params['state'], scheduled_at)
schedule_task_spec.name = schedule_task_name
schedule_task_spec.description = schedule_task_desc
schedule_task_spec.scheduler = vim.scheduler.OnceTaskScheduler()
schedule_task_spec.scheduler.runAt = dt
schedule_task_spec.action = vim.action.MethodAction()
schedule_task_spec.action.name = powerstate[module.params['state']]
schedule_task_spec.enabled = module.params['schedule_task_enabled']
try:
pyv.content.scheduledTaskManager.CreateScheduledTask(
vm, schedule_task_spec)
# As this is async task, we create scheduled task and mark state to changed.
module.exit_json(changed=True)
except vim.fault.InvalidName as e:
module.fail_json(
msg="Failed to create scheduled task %s for %s : %s" %
(module.params.get('state'), vm.name, to_native(e.msg)))
except vim.fault.DuplicateName as e:
module.exit_json(changed=False, details=to_native(e.msg))
except vmodl.fault.InvalidArgument as e:
module.fail_json(
msg="Failed to create scheduled task %s as specifications "
"given are invalid: %s" %
(module.params.get('state'), to_native(e.msg)))
else:
# Check if a virtual machine is locked by a question
if check_answer_question_status(vm) and module.params['answer']:
try:
responses = make_answer_response(vm,
module.params['answer'])
answer_question(vm, responses)
except Exception as e:
module.fail_json(msg="%s" % e)
# Wait until a virtual machine is unlocked
while True:
if check_answer_question_status(vm) is False:
break
result['changed'] = True
result['instance'] = gather_vm_facts(pyv.content, vm)
else:
result = set_vm_power_state(
pyv.content, vm, module.params['state'],
module.params['force'],
module.params['state_change_timeout'],
module.params['answer'])
result['answer'] = module.params['answer']
else:
id = module.params.get('uuid') or module.params.get(
'moid') or module.params.get('name')
module.fail_json(
msg=
"Unable to set power state for non-existing virtual machine : '%s'"
% id)
if result.get('failed') is True:
module.fail_json(**result)
module.exit_json(**result)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(portgroup_name=dict(required=True, type='str'),
switch_name=dict(required=True, type='str'),
vlan_id=dict(required=True, type='str'),
num_ports=dict(required=True, type='int'),
portgroup_type=dict(
required=True,
choices=['earlyBinding', 'lateBinding', 'ephemeral'],
type='str'),
state=dict(required=True,
choices=['present', 'absent'],
type='str'),
vlan_trunk=dict(type='bool', default=False),
vlan_private=dict(type='bool', default=False),
network_policy=dict(type='dict',
options=dict(promiscuous=dict(type='bool',
default=False),
forged_transmits=dict(
type='bool', default=False),
mac_changes=dict(type='bool',
default=False)),
default=dict(promiscuous=False,
forged_transmits=False,
mac_changes=False)),
teaming_policy=dict(
type='dict',
options=dict(inbound_policy=dict(type='bool', default=False),
notify_switches=dict(type='bool', default=True),
rolling_order=dict(type='bool', default=False),
load_balance_policy=dict(
type='str',
default='loadbalance_srcid',
choices=[
'loadbalance_ip',
'loadbalance_srcmac',
'loadbalance_srcid',
'loadbalance_loadbased',
'failover_explicit',
],
)),
default=dict(
inbound_policy=False,
notify_switches=True,
rolling_order=False,
load_balance_policy='loadbalance_srcid',
),
),
port_policy=dict(
type='dict',
options=dict(
block_override=dict(type='bool', default=True),
ipfix_override=dict(type='bool', default=False),
live_port_move=dict(type='bool', default=False),
network_rp_override=dict(type='bool', default=False),
port_config_reset_at_disconnect=dict(type='bool',
default=True),
security_override=dict(type='bool', default=False),
shaping_override=dict(type='bool', default=False),
traffic_filter_override=dict(type='bool', default=False),
uplink_teaming_override=dict(type='bool', default=False),
vendor_config_override=dict(type='bool', default=False),
vlan_override=dict(type='bool', default=False)),
default=dict(block_override=True,
ipfix_override=False,
live_port_move=False,
network_rp_override=False,
port_config_reset_at_disconnect=True,
security_override=False,
shaping_override=False,
traffic_filter_override=False,
uplink_teaming_override=False,
vendor_config_override=False,
vlan_override=False))))
module = AnsibleModule(argument_spec=argument_spec,
mutually_exclusive=[['vlan_trunk', 'vlan_private']],
supports_check_mode=True)
vmware_dvs_portgroup = VMwareDvsPortgroup(module)
vmware_dvs_portgroup.process_state()
def main():
"""
Main method
"""
argument_spec = vmware_argument_spec()
argument_spec.update(
name=dict(type='str'),
uuid=dict(type='str'),
moid=dict(type='str'),
use_instance_uuid=dict(type='bool', default=False),
destination_vm_name=dict(type='str', required=True),
destination_datastore=dict(type='str', required=True),
destination_host=dict(type='str', required=True),
destination_vcenter=dict(type='str', required=True),
destination_vcenter_username=dict(type='str', required=True),
destination_vcenter_password=dict(type='str',
required=True,
no_log=True),
destination_vcenter_port=dict(type='int', default=443),
destination_vcenter_validate_certs=dict(type='bool', default=False),
destination_vm_folder=dict(type='str', required=True),
destination_resource_pool=dict(type='str', default=None),
state=dict(type='str',
default='present',
choices=['present', 'poweredon']))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_one_of=[
['uuid', 'name', 'moid'],
],
mutually_exclusive=[
['uuid', 'name', 'moid'],
],
)
result = {'failed': False, 'changed': False}
if module.check_mode:
if module.params['state'] in ['present']:
result.update(vm_name=module.params['destination_vm_name'],
vcenter=module.params['destination_vcenter'],
host=module.params['destination_host'],
datastore=module.params['destination_datastore'],
vm_folder=module.params['destination_vm_folder'],
state=module.params['state'],
changed=True,
desired_operation='Create VM with PowerOff State')
if module.params['state'] == 'poweredon':
result.update(vm_name=module.params['destination_vm_name'],
vcenter=module.params['destination_vcenter'],
host=module.params['destination_host'],
datastore=module.params['destination_datastore'],
vm_folder=module.params['destination_vm_folder'],
state=module.params['state'],
changed=True,
desired_operation='Create VM with PowerON State')
module.exit_json(**result)
clone_manager = CrossVCCloneManager(module)
clone_manager.sanitize_params()
clone_manager.populate_specs()
result = clone_manager.clone()
if result['failed']:
module.fail_json(**result)
else:
module.exit_json(**result)
def main():
"""Main"""
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(
datacenter_name=dict(aliases=['datacenter']),
folder=dict(),
switch_name=dict(required=True, aliases=['switch', 'dvswitch']),
mtu=dict(type='int', default=1500),
multicast_filtering_mode=dict(type='str',
default='basic',
choices=['basic', 'snooping']),
switch_version=dict(
choices=['5.0.0', '5.1.0', '5.5.0', '6.0.0', '6.5.0', '6.6.0'],
aliases=['version'],
default=None),
uplink_quantity=dict(type='int'),
uplink_prefix=dict(type='str', default='Uplink '),
discovery_proto=dict(type='str',
choices=['cdp', 'lldp', 'disabled'],
default='cdp',
aliases=['discovery_protocol']),
discovery_operation=dict(type='str',
choices=['both', 'advertise', 'listen'],
default='listen'),
health_check=dict(
type='dict',
options=dict(
vlan_mtu=dict(type='bool', default=False),
teaming_failover=dict(type='bool', default=False),
vlan_mtu_interval=dict(type='int', default=0),
teaming_failover_interval=dict(type='int', default=0),
),
default=dict(
vlan_mtu=False,
teaming_failover=False,
vlan_mtu_interval=0,
teaming_failover_interval=0,
),
),
contact=dict(
type='dict',
options=dict(
name=dict(type='str'),
description=dict(type='str'),
),
),
description=dict(type='str'),
state=dict(default='present', choices=['present', 'absent']),
))
module = AnsibleModule(
argument_spec=argument_spec,
required_if=[
('state', 'present', ['uplink_quantity']),
],
required_one_of=[
['folder', 'datacenter_name'],
],
mutually_exclusive=[
['folder', 'datacenter_name'],
],
supports_check_mode=True,
)
vmware_dvswitch = VMwareDvSwitch(module)
vmware_dvswitch.process_state()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(datacenter=dict(type='str'),
cluster=dict(type='str'),
folder=dict(type='str'),
vm_id=dict(type='str', required=True),
vm_id_type=dict(default='vm_name',
type='str',
choices=[
'inventory_path', 'uuid', 'instance_uuid',
'dns_name', 'vm_name'
]),
vm_username=dict(type='str', required=True),
vm_password=dict(type='str', no_log=True, required=True),
directory=dict(type='dict',
default=None,
options=dict(operation=dict(
required=True,
type='str',
choices=['create', 'delete', 'mktemp']),
path=dict(required=False, type='str'),
prefix=dict(required=False,
type='str'),
suffix=dict(required=False,
type='str'),
recurse=dict(required=False,
type='bool',
default=False))),
copy=dict(type='dict',
default=None,
options=dict(src=dict(required=True, type='str'),
dest=dict(required=True, type='str'),
overwrite=dict(required=False,
type='bool',
default=False))),
fetch=dict(type='dict',
default=None,
options=dict(
src=dict(required=True, type='str'),
dest=dict(required=True, type='str'),
))))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False,
required_if=[['vm_id_type', 'inventory_path', ['folder']]],
mutually_exclusive=[['directory', 'copy', 'fetch']],
required_one_of=[['directory', 'copy', 'fetch']],
)
if module.params['directory']:
if module.params['directory']['operation'] in (
'create', 'delete') and not module.params['directory']['path']:
module.fail_json(
msg=
'directory.path is required when operation is "create" or "delete"'
)
if module.params['directory']['operation'] == 'mktemp' and not (
module.params['directory']['prefix']
and module.params['directory']['suffix']):
module.fail_json(
msg=
'directory.prefix and directory.suffix are required when operation is "mktemp"'
)
if module.params[
'vm_id_type'] == 'inventory_path' and not module.params['folder']:
module.fail_json(
msg='Folder is required parameter when vm_id_type is inventory_path'
)
VmwareGuestFileManager(module)
def main():
argument_spec = vmware_argument_spec()
module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True)
vmware_rp_mgr = ResourcePoolInfoManager(module)
module.exit_json(changed=False, resource_pool_info=vmware_rp_mgr.gather_rp_info())
