mirror of
https://github.com/ansible-collections/community.general.git
synced 2024-09-14 20:13:21 +02:00
858 lines
31 KiB
Python
858 lines
31 KiB
Python
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# (c) 2018, Simon Dodsley (simon@purestorage.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 = r'''
|
|
---
|
|
module: purefa_facts
|
|
deprecated:
|
|
removed_in: 3.0.0 # was Ansible 2.13
|
|
why: Deprecated in favor of C(_info) module.
|
|
alternative: Use M(purestorage.flasharray.purefa_info) instead.
|
|
short_description: Collect facts from Pure Storage FlashArray
|
|
description:
|
|
- Collect facts information from a Pure Storage Flasharray running the
|
|
Purity//FA operating system. By default, the module will collect basic
|
|
fact information including hosts, host groups, protection
|
|
groups and volume counts. Additional fact information can be collected
|
|
based on the configured set of arguments.
|
|
author:
|
|
- Pure Storage ansible Team (@sdodsley) <pure-ansible-team@purestorage.com>
|
|
options:
|
|
gather_subset:
|
|
description:
|
|
- When supplied, this argument will define the facts to be collected.
|
|
Possible values for this include all, minimum, config, performance,
|
|
capacity, network, subnet, interfaces, hgroups, pgroups, hosts,
|
|
admins, volumes, snapshots, pods, vgroups, offload, apps and arrays.
|
|
type: list
|
|
required: false
|
|
default: minimum
|
|
extends_documentation_fragment:
|
|
- community.general.purestorage.fa
|
|
|
|
'''
|
|
|
|
EXAMPLES = r'''
|
|
- name: Collect default set of facts
|
|
community.general.purefa_facts:
|
|
fa_url: 10.10.10.2
|
|
api_token: e31060a7-21fc-e277-6240-25983c6c4592
|
|
|
|
- name: Collect configuration and capacity facts
|
|
community.general.purefa_facts:
|
|
gather_subset:
|
|
- config
|
|
- capacity
|
|
fa_url: 10.10.10.2
|
|
api_token: e31060a7-21fc-e277-6240-25983c6c4592
|
|
|
|
- name: Collect all facts
|
|
community.general.purefa_facts:
|
|
gather_subset:
|
|
- all
|
|
fa_url: 10.10.10.2
|
|
api_token: e31060a7-21fc-e277-6240-25983c6c4592
|
|
'''
|
|
|
|
RETURN = r'''
|
|
ansible_facts:
|
|
description: Returns the facts collected from the FlashArray
|
|
returned: always
|
|
type: complex
|
|
sample: {
|
|
"capacity": {},
|
|
"config": {
|
|
"directory_service": {
|
|
"array_admin_group": null,
|
|
"base_dn": null,
|
|
"bind_password": null,
|
|
"bind_user": null,
|
|
"check_peer": false,
|
|
"enabled": false,
|
|
"group_base": null,
|
|
"readonly_group": null,
|
|
"storage_admin_group": null,
|
|
"uri": []
|
|
},
|
|
"dns": {
|
|
"domain": "domain.com",
|
|
"nameservers": [
|
|
"8.8.8.8",
|
|
"8.8.4.4"
|
|
]
|
|
},
|
|
"ntp": [
|
|
"0.ntp.pool.org",
|
|
"1.ntp.pool.org",
|
|
"2.ntp.pool.org",
|
|
"3.ntp.pool.org"
|
|
],
|
|
"smtp": [
|
|
{
|
|
"enabled": true,
|
|
"name": "alerts@acme.com"
|
|
},
|
|
{
|
|
"enabled": true,
|
|
"name": "user@acme.com"
|
|
}
|
|
],
|
|
"snmp": [
|
|
{
|
|
"auth_passphrase": null,
|
|
"auth_protocol": null,
|
|
"community": null,
|
|
"host": "localhost",
|
|
"name": "localhost",
|
|
"privacy_passphrase": null,
|
|
"privacy_protocol": null,
|
|
"user": null,
|
|
"version": "v2c"
|
|
}
|
|
],
|
|
"ssl_certs": {
|
|
"country": null,
|
|
"email": null,
|
|
"issued_by": "",
|
|
"issued_to": "",
|
|
"key_size": 2048,
|
|
"locality": null,
|
|
"organization": "Acme Storage, Inc.",
|
|
"organizational_unit": "Acme Storage, Inc.",
|
|
"state": null,
|
|
"status": "self-signed",
|
|
"valid_from": "2017-08-11T23:09:06Z",
|
|
"valid_to": "2027-08-09T23:09:06Z"
|
|
},
|
|
"syslog": []
|
|
},
|
|
"default": {
|
|
"array_name": "flasharray1",
|
|
"connected_arrays": 1,
|
|
"hostgroups": 0,
|
|
"hosts": 10,
|
|
"pods": 3,
|
|
"protection_groups": 1,
|
|
"purity_version": "5.0.4",
|
|
"snapshots": 1,
|
|
"volume_groups": 2
|
|
},
|
|
"hgroups": {},
|
|
"hosts": {
|
|
"host1": {
|
|
"hgroup": null,
|
|
"iqn": [
|
|
"iqn.1994-05.com.redhat:2f6f5715a533"
|
|
],
|
|
"wwn": []
|
|
},
|
|
"host2": {
|
|
"hgroup": null,
|
|
"iqn": [
|
|
"iqn.1994-05.com.redhat:d17fb13fe0b"
|
|
],
|
|
"wwn": []
|
|
},
|
|
"host3": {
|
|
"hgroup": null,
|
|
"iqn": [
|
|
"iqn.1994-05.com.redhat:97b1351bfb2"
|
|
],
|
|
"wwn": []
|
|
},
|
|
"host4": {
|
|
"hgroup": null,
|
|
"iqn": [
|
|
"iqn.1994-05.com.redhat:dd84e9a7b2cb"
|
|
],
|
|
"wwn": [
|
|
"10000000C96C48D1",
|
|
"10000000C96C48D2"
|
|
]
|
|
}
|
|
},
|
|
"interfaces": {
|
|
"CT0.ETH4": "iqn.2010-06.com.purestorage:flasharray.2111b767484e4682",
|
|
"CT0.ETH5": "iqn.2010-06.com.purestorage:flasharray.2111b767484e4682",
|
|
"CT1.ETH4": "iqn.2010-06.com.purestorage:flasharray.2111b767484e4682",
|
|
"CT1.ETH5": "iqn.2010-06.com.purestorage:flasharray.2111b767484e4682"
|
|
},
|
|
"network": {
|
|
"ct0.eth0": {
|
|
"address": "10.10.10.10",
|
|
"gateway": "10.10.10.1",
|
|
"hwaddr": "ec:f4:bb:c8:8a:04",
|
|
"mtu": 1500,
|
|
"netmask": "255.255.255.0",
|
|
"services": [
|
|
"management"
|
|
],
|
|
"speed": 1000000000
|
|
},
|
|
"ct0.eth2": {
|
|
"address": "10.10.10.11",
|
|
"gateway": null,
|
|
"hwaddr": "ec:f4:bb:c8:8a:00",
|
|
"mtu": 1500,
|
|
"netmask": "255.255.255.0",
|
|
"services": [
|
|
"replication"
|
|
],
|
|
"speed": 10000000000
|
|
},
|
|
"ct0.eth3": {
|
|
"address": "10.10.10.12",
|
|
"gateway": null,
|
|
"hwaddr": "ec:f4:bb:c8:8a:02",
|
|
"mtu": 1500,
|
|
"netmask": "255.255.255.0",
|
|
"services": [
|
|
"replication"
|
|
],
|
|
"speed": 10000000000
|
|
},
|
|
"ct0.eth4": {
|
|
"address": "10.10.10.13",
|
|
"gateway": null,
|
|
"hwaddr": "90:e2:ba:83:79:0c",
|
|
"mtu": 1500,
|
|
"netmask": "255.255.255.0",
|
|
"services": [
|
|
"iscsi"
|
|
],
|
|
"speed": 10000000000
|
|
},
|
|
"ct0.eth5": {
|
|
"address": "10.10.10.14",
|
|
"gateway": null,
|
|
"hwaddr": "90:e2:ba:83:79:0d",
|
|
"mtu": 1500,
|
|
"netmask": "255.255.255.0",
|
|
"services": [
|
|
"iscsi"
|
|
],
|
|
"speed": 10000000000
|
|
},
|
|
"vir0": {
|
|
"address": "10.10.10.20",
|
|
"gateway": "10.10.10.1",
|
|
"hwaddr": "fe:ba:e9:e7:6b:0f",
|
|
"mtu": 1500,
|
|
"netmask": "255.255.255.0",
|
|
"services": [
|
|
"management"
|
|
],
|
|
"speed": 1000000000
|
|
}
|
|
},
|
|
"offload": {
|
|
"nfstarget": {
|
|
"address": "10.0.2.53",
|
|
"mount_options": null,
|
|
"mount_point": "/offload",
|
|
"protocol": "nfs",
|
|
"status": "scanning"
|
|
}
|
|
},
|
|
"performance": {
|
|
"input_per_sec": 8191,
|
|
"output_per_sec": 0,
|
|
"queue_depth": 1,
|
|
"reads_per_sec": 0,
|
|
"san_usec_per_write_op": 15,
|
|
"usec_per_read_op": 0,
|
|
"usec_per_write_op": 642,
|
|
"writes_per_sec": 2
|
|
},
|
|
"pgroups": {
|
|
"consisgroup-07b6b983-986e-46f5-bdc3-deaa3dbb299e-cinder": {
|
|
"hgroups": null,
|
|
"hosts": null,
|
|
"source": "host1",
|
|
"targets": null,
|
|
"volumes": [
|
|
"volume-1"
|
|
]
|
|
}
|
|
},
|
|
"pods": {
|
|
"srm-pod": {
|
|
"arrays": [
|
|
{
|
|
"array_id": "52595f7e-b460-4b46-8851-a5defd2ac192",
|
|
"mediator_status": "online",
|
|
"name": "sn1-405-c09-37",
|
|
"status": "online"
|
|
},
|
|
{
|
|
"array_id": "a2c32301-f8a0-4382-949b-e69b552ce8ca",
|
|
"mediator_status": "online",
|
|
"name": "sn1-420-c11-31",
|
|
"status": "online"
|
|
}
|
|
],
|
|
"source": null
|
|
}
|
|
},
|
|
"snapshots": {
|
|
"consisgroup.cgsnapshot": {
|
|
"created": "2018-03-28T09:34:02Z",
|
|
"size": 13958643712,
|
|
"source": "volume-1"
|
|
}
|
|
},
|
|
"subnet": {},
|
|
"vgroups": {
|
|
"vvol--vSphere-HA-0ffc7dd1-vg": {
|
|
"volumes": [
|
|
"vvol--vSphere-HA-0ffc7dd1-vg/Config-aad5d7c6"
|
|
]
|
|
}
|
|
},
|
|
"volumes": {
|
|
"ansible_data": {
|
|
"bandwidth": null,
|
|
"hosts": [
|
|
[
|
|
"host1",
|
|
1
|
|
]
|
|
],
|
|
"serial": "43BE47C12334399B000114A6",
|
|
"size": 1099511627776,
|
|
"source": null
|
|
}
|
|
}
|
|
}
|
|
'''
|
|
|
|
|
|
from ansible.module_utils.basic import AnsibleModule
|
|
from ansible_collections.community.general.plugins.module_utils.pure import get_system, purefa_argument_spec
|
|
|
|
|
|
ADMIN_API_VERSION = '1.14'
|
|
S3_REQUIRED_API_VERSION = '1.16'
|
|
LATENCY_REQUIRED_API_VERSION = '1.16'
|
|
AC_REQUIRED_API_VERSION = '1.14'
|
|
CAP_REQUIRED_API_VERSION = '1.6'
|
|
SAN_REQUIRED_API_VERSION = '1.10'
|
|
NVME_API_VERSION = '1.16'
|
|
PREFERRED_API_VERSION = '1.15'
|
|
CONN_STATUS_API_VERSION = '1.17'
|
|
|
|
|
|
def generate_default_dict(array):
|
|
default_facts = {}
|
|
defaults = array.get()
|
|
api_version = array._list_available_rest_versions()
|
|
if AC_REQUIRED_API_VERSION in api_version:
|
|
default_facts['volume_groups'] = len(array.list_vgroups())
|
|
default_facts['connected_arrays'] = len(array.list_array_connections())
|
|
default_facts['pods'] = len(array.list_pods())
|
|
default_facts['connection_key'] = array.get(connection_key=True)['connection_key']
|
|
hosts = array.list_hosts()
|
|
admins = array.list_admins()
|
|
snaps = array.list_volumes(snap=True, pending=True)
|
|
pgroups = array.list_pgroups(pending=True)
|
|
hgroups = array.list_hgroups()
|
|
# Old FA arrays only report model from the primary controller
|
|
ct0_model = array.get_hardware('CT0')['model']
|
|
if ct0_model:
|
|
model = ct0_model
|
|
else:
|
|
ct1_model = array.get_hardware('CT1')['model']
|
|
model = ct1_model
|
|
default_facts['array_model'] = model
|
|
default_facts['array_name'] = defaults['array_name']
|
|
default_facts['purity_version'] = defaults['version']
|
|
default_facts['hosts'] = len(hosts)
|
|
default_facts['snapshots'] = len(snaps)
|
|
default_facts['protection_groups'] = len(pgroups)
|
|
default_facts['hostgroups'] = len(hgroups)
|
|
default_facts['admins'] = len(admins)
|
|
return default_facts
|
|
|
|
|
|
def generate_perf_dict(array):
|
|
perf_facts = {}
|
|
api_version = array._list_available_rest_versions()
|
|
if LATENCY_REQUIRED_API_VERSION in api_version:
|
|
latency_info = array.get(action='monitor', latency=True)[0]
|
|
perf_info = array.get(action='monitor')[0]
|
|
# IOPS
|
|
perf_facts['writes_per_sec'] = perf_info['writes_per_sec']
|
|
perf_facts['reads_per_sec'] = perf_info['reads_per_sec']
|
|
|
|
# Bandwidth
|
|
perf_facts['input_per_sec'] = perf_info['input_per_sec']
|
|
perf_facts['output_per_sec'] = perf_info['output_per_sec']
|
|
|
|
# Latency
|
|
if LATENCY_REQUIRED_API_VERSION in api_version:
|
|
perf_facts['san_usec_per_read_op'] = latency_info['san_usec_per_read_op']
|
|
perf_facts['san_usec_per_write_op'] = latency_info['san_usec_per_write_op']
|
|
perf_facts['queue_usec_per_read_op'] = latency_info['queue_usec_per_read_op']
|
|
perf_facts['queue_usec_per_write_op'] = latency_info['queue_usec_per_write_op']
|
|
perf_facts['qos_rate_limit_usec_per_read_op'] = latency_info['qos_rate_limit_usec_per_read_op']
|
|
perf_facts['qos_rate_limit_usec_per_write_op'] = latency_info['qos_rate_limit_usec_per_write_op']
|
|
perf_facts['local_queue_usec_per_op'] = perf_info['local_queue_usec_per_op']
|
|
perf_facts['usec_per_read_op'] = perf_info['usec_per_read_op']
|
|
perf_facts['usec_per_write_op'] = perf_info['usec_per_write_op']
|
|
perf_facts['queue_depth'] = perf_info['queue_depth']
|
|
return perf_facts
|
|
|
|
|
|
def generate_config_dict(array):
|
|
config_facts = {}
|
|
api_version = array._list_available_rest_versions()
|
|
# DNS
|
|
config_facts['dns'] = array.get_dns()
|
|
# SMTP
|
|
config_facts['smtp'] = array.list_alert_recipients()
|
|
# SNMP
|
|
config_facts['snmp'] = array.list_snmp_managers()
|
|
config_facts['snmp_v3_engine_id'] = array.get_snmp_engine_id()['engine_id']
|
|
# DS
|
|
config_facts['directory_service'] = array.get_directory_service()
|
|
if S3_REQUIRED_API_VERSION in api_version:
|
|
config_facts['directory_service_roles'] = {}
|
|
roles = array.list_directory_service_roles()
|
|
for role in range(0, len(roles)):
|
|
role_name = roles[role]['name']
|
|
config_facts['directory_service_roles'][role_name] = {
|
|
'group': roles[role]['group'],
|
|
'group_base': roles[role]['group_base'],
|
|
}
|
|
else:
|
|
config_facts['directory_service'].update(array.get_directory_service(groups=True))
|
|
# NTP
|
|
config_facts['ntp'] = array.get(ntpserver=True)['ntpserver']
|
|
# SYSLOG
|
|
config_facts['syslog'] = array.get(syslogserver=True)['syslogserver']
|
|
# Phonehome
|
|
config_facts['phonehome'] = array.get(phonehome=True)['phonehome']
|
|
# Proxy
|
|
config_facts['proxy'] = array.get(proxy=True)['proxy']
|
|
# Relay Host
|
|
config_facts['relayhost'] = array.get(relayhost=True)['relayhost']
|
|
# Sender Domain
|
|
config_facts['senderdomain'] = array.get(senderdomain=True)['senderdomain']
|
|
# SYSLOG
|
|
config_facts['syslog'] = array.get(syslogserver=True)['syslogserver']
|
|
# Idle Timeout
|
|
config_facts['idle_timeout'] = array.get(idle_timeout=True)['idle_timeout']
|
|
# SCSI Timeout
|
|
config_facts['scsi_timeout'] = array.get(scsi_timeout=True)['scsi_timeout']
|
|
# SSL
|
|
config_facts['ssl_certs'] = array.get_certificate()
|
|
# Global Admin settings
|
|
if S3_REQUIRED_API_VERSION in api_version:
|
|
config_facts['global_admin'] = array.get_global_admin_attributes()
|
|
return config_facts
|
|
|
|
|
|
def generate_admin_dict(array):
|
|
api_version = array._list_available_rest_versions()
|
|
admin_facts = {}
|
|
if ADMIN_API_VERSION in api_version:
|
|
admins = array.list_admins()
|
|
for admin in range(0, len(admins)):
|
|
admin_name = admins[admin]['name']
|
|
admin_facts[admin_name] = {
|
|
'type': admins[admin]['type'],
|
|
'role': admins[admin]['role'],
|
|
}
|
|
return admin_facts
|
|
|
|
|
|
def generate_subnet_dict(array):
|
|
sub_facts = {}
|
|
subnets = array.list_subnets()
|
|
for sub in range(0, len(subnets)):
|
|
sub_name = subnets[sub]['name']
|
|
if subnets[sub]['enabled']:
|
|
sub_facts[sub_name] = {
|
|
'gateway': subnets[sub]['gateway'],
|
|
'mtu': subnets[sub]['mtu'],
|
|
'vlan': subnets[sub]['vlan'],
|
|
'prefix': subnets[sub]['prefix'],
|
|
'interfaces': subnets[sub]['interfaces'],
|
|
'services': subnets[sub]['services'],
|
|
}
|
|
return sub_facts
|
|
|
|
|
|
def generate_network_dict(array):
|
|
net_facts = {}
|
|
ports = array.list_network_interfaces()
|
|
for port in range(0, len(ports)):
|
|
int_name = ports[port]['name']
|
|
net_facts[int_name] = {
|
|
'hwaddr': ports[port]['hwaddr'],
|
|
'mtu': ports[port]['mtu'],
|
|
'enabled': ports[port]['enabled'],
|
|
'speed': ports[port]['speed'],
|
|
'address': ports[port]['address'],
|
|
'slaves': ports[port]['slaves'],
|
|
'services': ports[port]['services'],
|
|
'gateway': ports[port]['gateway'],
|
|
'netmask': ports[port]['netmask'],
|
|
}
|
|
if ports[port]['subnet']:
|
|
subnets = array.get_subnet(ports[port]['subnet'])
|
|
if subnets['enabled']:
|
|
net_facts[int_name]['subnet'] = {
|
|
'name': subnets['name'],
|
|
'prefix': subnets['prefix'],
|
|
'vlan': subnets['vlan'],
|
|
}
|
|
return net_facts
|
|
|
|
|
|
def generate_capacity_dict(array):
|
|
capacity_facts = {}
|
|
api_version = array._list_available_rest_versions()
|
|
if CAP_REQUIRED_API_VERSION in api_version:
|
|
volumes = array.list_volumes(pending=True)
|
|
capacity_facts['provisioned_space'] = sum(item['size'] for item in volumes)
|
|
capacity = array.get(space=True)
|
|
total_capacity = capacity[0]['capacity']
|
|
used_space = capacity[0]["total"]
|
|
capacity_facts['free_space'] = total_capacity - used_space
|
|
capacity_facts['total_capacity'] = total_capacity
|
|
capacity_facts['data_reduction'] = capacity[0]['data_reduction']
|
|
capacity_facts['system_space'] = capacity[0]['system']
|
|
capacity_facts['volume_space'] = capacity[0]['volumes']
|
|
capacity_facts['shared_space'] = capacity[0]['shared_space']
|
|
capacity_facts['snapshot_space'] = capacity[0]['snapshots']
|
|
capacity_facts['thin_provisioning'] = capacity[0]['thin_provisioning']
|
|
capacity_facts['total_reduction'] = capacity[0]['total_reduction']
|
|
|
|
return capacity_facts
|
|
|
|
|
|
def generate_snap_dict(array):
|
|
snap_facts = {}
|
|
snaps = array.list_volumes(snap=True)
|
|
for snap in range(0, len(snaps)):
|
|
snapshot = snaps[snap]['name']
|
|
snap_facts[snapshot] = {
|
|
'size': snaps[snap]['size'],
|
|
'source': snaps[snap]['source'],
|
|
'created': snaps[snap]['created'],
|
|
}
|
|
return snap_facts
|
|
|
|
|
|
def generate_vol_dict(array):
|
|
volume_facts = {}
|
|
vols = array.list_volumes()
|
|
for vol in range(0, len(vols)):
|
|
volume = vols[vol]['name']
|
|
volume_facts[volume] = {
|
|
'source': vols[vol]['source'],
|
|
'size': vols[vol]['size'],
|
|
'serial': vols[vol]['serial'],
|
|
'hosts': [],
|
|
'bandwidth': ""
|
|
}
|
|
api_version = array._list_available_rest_versions()
|
|
if AC_REQUIRED_API_VERSION in api_version:
|
|
qvols = array.list_volumes(qos=True)
|
|
for qvol in range(0, len(qvols)):
|
|
volume = qvols[qvol]['name']
|
|
qos = qvols[qvol]['bandwidth_limit']
|
|
volume_facts[volume]['bandwidth'] = qos
|
|
vvols = array.list_volumes(protocol_endpoint=True)
|
|
for vvol in range(0, len(vvols)):
|
|
volume = vvols[vvol]['name']
|
|
volume_facts[volume] = {
|
|
'source': vvols[vvol]['source'],
|
|
'serial': vvols[vvol]['serial'],
|
|
'hosts': []
|
|
}
|
|
cvols = array.list_volumes(connect=True)
|
|
for cvol in range(0, len(cvols)):
|
|
volume = cvols[cvol]['name']
|
|
voldict = [cvols[cvol]['host'], cvols[cvol]['lun']]
|
|
volume_facts[volume]['hosts'].append(voldict)
|
|
return volume_facts
|
|
|
|
|
|
def generate_host_dict(array):
|
|
api_version = array._list_available_rest_versions()
|
|
host_facts = {}
|
|
hosts = array.list_hosts()
|
|
for host in range(0, len(hosts)):
|
|
hostname = hosts[host]['name']
|
|
tports = []
|
|
host_all_info = array.get_host(hostname, all=True)
|
|
if host_all_info:
|
|
tports = host_all_info[0]['target_port']
|
|
host_facts[hostname] = {
|
|
'hgroup': hosts[host]['hgroup'],
|
|
'iqn': hosts[host]['iqn'],
|
|
'wwn': hosts[host]['wwn'],
|
|
'personality': array.get_host(hostname,
|
|
personality=True)['personality'],
|
|
'target_port': tports
|
|
}
|
|
if NVME_API_VERSION in api_version:
|
|
host_facts[hostname]['nqn'] = hosts[host]['nqn']
|
|
if PREFERRED_API_VERSION in api_version:
|
|
hosts = array.list_hosts(preferred_array=True)
|
|
for host in range(0, len(hosts)):
|
|
hostname = hosts[host]['name']
|
|
host_facts[hostname]['preferred_array'] = hosts[host]['preferred_array']
|
|
return host_facts
|
|
|
|
|
|
def generate_pgroups_dict(array):
|
|
pgroups_facts = {}
|
|
pgroups = array.list_pgroups()
|
|
for pgroup in range(0, len(pgroups)):
|
|
protgroup = pgroups[pgroup]['name']
|
|
pgroups_facts[protgroup] = {
|
|
'hgroups': pgroups[pgroup]['hgroups'],
|
|
'hosts': pgroups[pgroup]['hosts'],
|
|
'source': pgroups[pgroup]['source'],
|
|
'targets': pgroups[pgroup]['targets'],
|
|
'volumes': pgroups[pgroup]['volumes'],
|
|
}
|
|
prot_sched = array.get_pgroup(protgroup, schedule=True)
|
|
prot_reten = array.get_pgroup(protgroup, retention=True)
|
|
if prot_sched['snap_enabled'] or prot_sched['replicate_enabled']:
|
|
pgroups_facts[protgroup]['snap_freqyency'] = prot_sched['snap_frequency']
|
|
pgroups_facts[protgroup]['replicate_freqyency'] = prot_sched['replicate_frequency']
|
|
pgroups_facts[protgroup]['snap_enabled'] = prot_sched['snap_enabled']
|
|
pgroups_facts[protgroup]['replicate_enabled'] = prot_sched['replicate_enabled']
|
|
pgroups_facts[protgroup]['snap_at'] = prot_sched['snap_at']
|
|
pgroups_facts[protgroup]['replicate_at'] = prot_sched['replicate_at']
|
|
pgroups_facts[protgroup]['replicate_blackout'] = prot_sched['replicate_blackout']
|
|
pgroups_facts[protgroup]['per_day'] = prot_reten['per_day']
|
|
pgroups_facts[protgroup]['target_per_day'] = prot_reten['target_per_day']
|
|
pgroups_facts[protgroup]['target_days'] = prot_reten['target_days']
|
|
pgroups_facts[protgroup]['days'] = prot_reten['days']
|
|
pgroups_facts[protgroup]['all_for'] = prot_reten['all_for']
|
|
pgroups_facts[protgroup]['target_all_for'] = prot_reten['target_all_for']
|
|
if ":" in protgroup:
|
|
snap_transfers = array.get_pgroup(protgroup, snap=True, transfer=True)
|
|
pgroups_facts[protgroup]['snaps'] = {}
|
|
for snap_transfer in range(0, len(snap_transfers)):
|
|
snap = snap_transfers[snap_transfer]['name']
|
|
pgroups_facts[protgroup]['snaps'][snap] = {
|
|
'created': snap_transfers[snap_transfer]['created'],
|
|
'started': snap_transfers[snap_transfer]['started'],
|
|
'completed': snap_transfers[snap_transfer]['completed'],
|
|
'physical_bytes_written': snap_transfers[snap_transfer]['physical_bytes_written'],
|
|
'data_transferred': snap_transfers[snap_transfer]['data_transferred'],
|
|
'progress': snap_transfers[snap_transfer]['progress'],
|
|
}
|
|
return pgroups_facts
|
|
|
|
|
|
def generate_pods_dict(array):
|
|
pods_facts = {}
|
|
api_version = array._list_available_rest_versions()
|
|
if AC_REQUIRED_API_VERSION in api_version:
|
|
pods = array.list_pods()
|
|
for pod in range(0, len(pods)):
|
|
acpod = pods[pod]['name']
|
|
pods_facts[acpod] = {
|
|
'source': pods[pod]['source'],
|
|
'arrays': pods[pod]['arrays'],
|
|
}
|
|
return pods_facts
|
|
|
|
|
|
def generate_conn_array_dict(array):
|
|
conn_array_facts = {}
|
|
api_version = array._list_available_rest_versions()
|
|
if CONN_STATUS_API_VERSION in api_version:
|
|
carrays = array.list_connected_arrays()
|
|
for carray in range(0, len(carrays)):
|
|
arrayname = carrays[carray]['array_name']
|
|
conn_array_facts[arrayname] = {
|
|
'array_id': carrays[carray]['id'],
|
|
'throtled': carrays[carray]['throtled'],
|
|
'version': carrays[carray]['version'],
|
|
'type': carrays[carray]['type'],
|
|
'mgmt_ip': carrays[carray]['management_address'],
|
|
'repl_ip': carrays[carray]['replication_address'],
|
|
}
|
|
if CONN_STATUS_API_VERSION in api_version:
|
|
conn_array_facts[arrayname]['status'] = carrays[carray]['status']
|
|
return conn_array_facts
|
|
|
|
|
|
def generate_apps_dict(array):
|
|
apps_facts = {}
|
|
api_version = array._list_available_rest_versions()
|
|
if SAN_REQUIRED_API_VERSION in api_version:
|
|
apps = array.list_apps()
|
|
for app in range(0, len(apps)):
|
|
appname = apps[app]['name']
|
|
apps_facts[appname] = {
|
|
'version': apps[app]['version'],
|
|
'status': apps[app]['status'],
|
|
'description': apps[app]['description'],
|
|
}
|
|
return apps_facts
|
|
|
|
|
|
def generate_vgroups_dict(array):
|
|
vgroups_facts = {}
|
|
api_version = array._list_available_rest_versions()
|
|
if AC_REQUIRED_API_VERSION in api_version:
|
|
vgroups = array.list_vgroups()
|
|
for vgroup in range(0, len(vgroups)):
|
|
virtgroup = vgroups[vgroup]['name']
|
|
vgroups_facts[virtgroup] = {
|
|
'volumes': vgroups[vgroup]['volumes'],
|
|
}
|
|
return vgroups_facts
|
|
|
|
|
|
def generate_nfs_offload_dict(array):
|
|
offload_facts = {}
|
|
api_version = array._list_available_rest_versions()
|
|
if AC_REQUIRED_API_VERSION in api_version:
|
|
offload = array.list_nfs_offload()
|
|
for target in range(0, len(offload)):
|
|
offloadt = offload[target]['name']
|
|
offload_facts[offloadt] = {
|
|
'status': offload[target]['status'],
|
|
'mount_point': offload[target]['mount_point'],
|
|
'protocol': offload[target]['protocol'],
|
|
'mount_options': offload[target]['mount_options'],
|
|
'address': offload[target]['address'],
|
|
}
|
|
return offload_facts
|
|
|
|
|
|
def generate_s3_offload_dict(array):
|
|
offload_facts = {}
|
|
api_version = array._list_available_rest_versions()
|
|
if S3_REQUIRED_API_VERSION in api_version:
|
|
offload = array.list_s3_offload()
|
|
for target in range(0, len(offload)):
|
|
offloadt = offload[target]['name']
|
|
offload_facts[offloadt] = {
|
|
'status': offload[target]['status'],
|
|
'bucket': offload[target]['bucket'],
|
|
'protocol': offload[target]['protocol'],
|
|
'access_key_id': offload[target]['access_key_id'],
|
|
}
|
|
return offload_facts
|
|
|
|
|
|
def generate_hgroups_dict(array):
|
|
hgroups_facts = {}
|
|
hgroups = array.list_hgroups()
|
|
for hgroup in range(0, len(hgroups)):
|
|
hostgroup = hgroups[hgroup]['name']
|
|
hgroups_facts[hostgroup] = {
|
|
'hosts': hgroups[hgroup]['hosts'],
|
|
'pgs': [],
|
|
'vols': [],
|
|
}
|
|
pghgroups = array.list_hgroups(protect=True)
|
|
for pghg in range(0, len(pghgroups)):
|
|
pgname = pghgroups[pghg]['name']
|
|
hgroups_facts[pgname]['pgs'].append(pghgroups[pghg]['protection_group'])
|
|
volhgroups = array.list_hgroups(connect=True)
|
|
for pgvol in range(0, len(volhgroups)):
|
|
pgname = volhgroups[pgvol]['name']
|
|
volpgdict = [volhgroups[pgvol]['vol'], volhgroups[pgvol]['lun']]
|
|
hgroups_facts[pgname]['vols'].append(volpgdict)
|
|
return hgroups_facts
|
|
|
|
|
|
def generate_interfaces_dict(array):
|
|
api_version = array._list_available_rest_versions()
|
|
int_facts = {}
|
|
ports = array.list_ports()
|
|
for port in range(0, len(ports)):
|
|
int_name = ports[port]['name']
|
|
if ports[port]['wwn']:
|
|
int_facts[int_name] = ports[port]['wwn']
|
|
if ports[port]['iqn']:
|
|
int_facts[int_name] = ports[port]['iqn']
|
|
if NVME_API_VERSION in api_version:
|
|
if ports[port]['nqn']:
|
|
int_facts[int_name] = ports[port]['nqn']
|
|
return int_facts
|
|
|
|
|
|
def main():
|
|
argument_spec = purefa_argument_spec()
|
|
argument_spec.update(dict(
|
|
gather_subset=dict(default='minimum', type='list',)
|
|
))
|
|
|
|
module = AnsibleModule(argument_spec, supports_check_mode=False)
|
|
|
|
array = get_system(module)
|
|
|
|
subset = [test.lower() for test in module.params['gather_subset']]
|
|
valid_subsets = ('all', 'minimum', 'config', 'performance', 'capacity',
|
|
'network', 'subnet', 'interfaces', 'hgroups', 'pgroups',
|
|
'hosts', 'admins', 'volumes', 'snapshots', 'pods',
|
|
'vgroups', 'offload', 'apps', 'arrays')
|
|
subset_test = (test in valid_subsets for test in subset)
|
|
if not all(subset_test):
|
|
module.fail_json(msg="value must gather_subset must be one or more of: %s, got: %s"
|
|
% (",".join(valid_subsets), ",".join(subset)))
|
|
|
|
facts = {}
|
|
|
|
if 'minimum' in subset or 'all' in subset:
|
|
facts['default'] = generate_default_dict(array)
|
|
if 'performance' in subset or 'all' in subset:
|
|
facts['performance'] = generate_perf_dict(array)
|
|
if 'config' in subset or 'all' in subset:
|
|
facts['config'] = generate_config_dict(array)
|
|
if 'capacity' in subset or 'all' in subset:
|
|
facts['capacity'] = generate_capacity_dict(array)
|
|
if 'network' in subset or 'all' in subset:
|
|
facts['network'] = generate_network_dict(array)
|
|
if 'subnet' in subset or 'all' in subset:
|
|
facts['subnet'] = generate_subnet_dict(array)
|
|
if 'interfaces' in subset or 'all' in subset:
|
|
facts['interfaces'] = generate_interfaces_dict(array)
|
|
if 'hosts' in subset or 'all' in subset:
|
|
facts['hosts'] = generate_host_dict(array)
|
|
if 'volumes' in subset or 'all' in subset:
|
|
facts['volumes'] = generate_vol_dict(array)
|
|
if 'snapshots' in subset or 'all' in subset:
|
|
facts['snapshots'] = generate_snap_dict(array)
|
|
if 'hgroups' in subset or 'all' in subset:
|
|
facts['hgroups'] = generate_hgroups_dict(array)
|
|
if 'pgroups' in subset or 'all' in subset:
|
|
facts['pgroups'] = generate_pgroups_dict(array)
|
|
if 'pods' in subset or 'all' in subset:
|
|
facts['pods'] = generate_pods_dict(array)
|
|
if 'admins' in subset or 'all' in subset:
|
|
facts['admins'] = generate_admin_dict(array)
|
|
if 'vgroups' in subset or 'all' in subset:
|
|
facts['vgroups'] = generate_vgroups_dict(array)
|
|
if 'offload' in subset or 'all' in subset:
|
|
facts['nfs_offload'] = generate_nfs_offload_dict(array)
|
|
facts['s3_offload'] = generate_s3_offload_dict(array)
|
|
if 'apps' in subset or 'all' in subset:
|
|
facts['apps'] = generate_apps_dict(array)
|
|
if 'arrays' in subset or 'all' in subset:
|
|
facts['arrays'] = generate_conn_array_dict(array)
|
|
|
|
module.exit_json(ansible_facts={'ansible_purefa_facts': facts})
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|