Month: March 2025

from concurrent.futures import ThreadPoolExecutor, as_completed

import math
import time
import datetime
import argparse
import getpass

from humanfriendly import format_timespan

import urllib3
import pandas as pd
import keyring
import tqdm

import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots

import ntnx_aiops_py_client
import ntnx_vmm_py_client

class PrintColors:
    """Used for colored output formatting.
    """
    OK = '\033[92m' #GREEN
    SUCCESS = '\033[96m' #CYAN
    DATA = '\033[097m' #WHITE
    WARNING = '\033[93m' #YELLOW
    FAIL = '\033[91m' #RED
    STEP = '\033[95m' #PURPLE
    RESET = '\033[0m' #RESET COLOR

import ntnx_aiops_py_client

#* initialize variable for API client configuration
api_client_configuration = ntnx_aiops_py_client.Configuration()
api_client_configuration.host = api_server
api_client_configuration.username = username
api_client_configuration.password = secret

if secure is False:
    #! suppress warnings about insecure connections
    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
    #! suppress ssl certs verification
    api_client_configuration.verify_ssl = False

#* getting list of sources
client = ntnx_aiops_py_client.ApiClient(configuration=api_client_configuration)
entity_api = ntnx_aiops_py_client.StatsApi(api_client=client)
print(f"{PrintColors.OK}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [INFO] Fetching available sources...{PrintColors.RESET}")
response = entity_api.get_sources_v4() 
source_ext_id = next(iter([source.ext_id for source in response.data if source.source_name == 'nutanix']))

def fetch_entity_descriptors(client,source_ext_id,page,limit=50):
    '''fetch_entity_descriptors function.
        Args:
            client: a v4 Python SDK client object.
            source_ext_id: uuid of a valid source.
            page: page number to fetch.
            limit: number of entities to fetch.
        Returns:
    '''
    entity_api = ntnx_aiops_py_client.StatsApi(api_client=client)
    response = entity_api.get_entity_descriptors_v4(sourceExtId=source_ext_id,_page=page,_limit=limit)
    return response

#* getting entities and metrics descriptor for nutanix source
print(f"{PrintColors.OK}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [INFO] Fetching entities and descriptors for source nutanix...{PrintColors.RESET}")
entity_list=[]
response = entity_api.get_entity_descriptors_v4(sourceExtId=source_ext_id,_page=0,_limit=1)
total_available_results=response.metadata.total_available_results
page_count = math.ceil(total_available_results/limit)
with tqdm.tqdm(total=page_count, desc="Fetching pages") as progress_bar:
    with ThreadPoolExecutor(max_workers=10) as executor:
        futures = [executor.submit(
                fetch_entity_descriptors,
                client=client,
                source_ext_id=source_ext_id,
                page=page_number,
                limit=limit
            ) for page_number in range(0, page_count, 1)]
        for future in as_completed(futures):
            try:
                entities = future.result()
                entity_list.extend(entities.data)
            except Exception as e:
                print(f"{PrintColors.WARNING}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [WARNING] Task failed: {e}{PrintColors.RESET}")
            finally:
                progress_bar.update(1)
entity_descriptors_list = entity_list

descriptors={}
for item in entity_descriptors_list:
    entity_type = item.entity_type
    descriptors[entity_type] = {}
    for metric in item.metrics:
        metric_name = metric.name
        descriptors[entity_type][metric_name] = {}
        descriptors[entity_type][metric_name]['name'] = metric.name
        descriptors[entity_type][metric_name]['value_type'] = metric.value_type
        if metric.additional_properties is not None:
            descriptors[entity_type][metric_name]['description'] = next(iter([metric_property.value for metric_property in metric.additional_properties if metric_property.name == 'description']),None)
        else:
            descriptors[entity_type][metric_name]['description'] = None
for entity_type in descriptors.keys():
    print(f"{PrintColors.OK}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [INFO] Available metrics for {entity_type} are:{PrintColors.RESET}")
    for metric in sorted(descriptors[entity_type]):
        print(f"    {descriptors[entity_type][metric]['name']},{descriptors[entity_type][metric]['value_type']},{descriptors[entity_type][metric]['description']}")

checkScore,INT,None
cluster,STRING,None
controllerAvgIoLatencyMicros,INT,I/O latency in milliseconds from the Storage Controller.
controllerAvgReadIoLatencyMicros,INT,Storage Controller read latency in milliseconds.
controllerAvgReadIoSizeKb,INT,None
controllerAvgWriteIoLatencyMicros,INT,Storage Controller write latency in milliseconds.
controllerAvgWriteIoSizeKb,INT,None
controllerIoBandwidthKbps,INT,Data transferred in KB/second from the Storage Controller.
controllerNumIo,INT,None
controllerNumIops,INT,Input/Output operations per second from the Storage Controller.
controllerNumRandomIo,INT,None
controllerNumReadIo,INT,None
controllerNumReadIops,INT,Input/Output read operations per second from the Storage Controller
controllerNumSeqIo,INT,None
controllerNumWriteIo,INT,None
controllerNumWriteIops,INT,Input/Output write operations per second from the Storage Controller
controllerOplogDrainDestHddBytes,INT,None
controllerOplogDrainDestSsdBytes,INT,None
controllerRandomIoPpm,INT,None
controllerReadIoBandwidthKbps,INT,Read data transferred in KB/second from the Storage Controller.
controllerReadIoPpm,INT,Percent of Storage Controller IOPS that are reads.
controllerReadSourceEstoreHddLocalBytes,INT,None
controllerReadSourceEstoreHddRemoteBytes,INT,None
controllerReadSourceEstoreSsdLocalBytes,INT,None
controllerReadSourceEstoreSsdRemoteBytes,INT,None
controllerReadSourceOplogBytes,INT,None
controllerSeqIoPpm,INT,None
controllerSharedUsageBytes,INT,Shared Data usage
controllerSnapshotUsageBytes,INT,Snapshot usage Bytes
controllerStorageTierSsdUsageBytes,INT,None
controllerTimespanMicros,INT,None
controllerTotalIoSizeKb,INT,None
controllerTotalIoTimeMicros,INT,None
controllerTotalReadIoSizeKb,INT,None
controllerTotalReadIoTimeMicros,INT,None
controllerTotalTransformedUsageBytes,INT,None
controllerUserBytes,INT,Disk Usage Bytes
controllerWriteDestEstoreHddBytes,INT,None
controllerWriteDestEstoreSsdBytes,INT,None
controllerWriteIoBandwidthKbps,INT,Write data transferred in KB/second from the Storage Controller.
controllerWriteIoPpm,INT,Percent of Storage Controller IOPS that are writes.
controllerWss120SecondReadMb,INT,None
controllerWss120SecondUnionMb,INT,None
controllerWss120SecondWriteMb,INT,None
controllerWss3600SecondReadMb,INT,Read I/O working set size
controllerWss3600SecondUnionMb,INT,I/O working set size
controllerWss3600SecondWriteMb,INT,Write I/O working set size
diskCapacityBytes,INT,None
diskUsagePpm,INT,Disk Usage in percentage
frameBufferUsagePpm,INT,Usage of the GPU's framebuffer
gpuUsagePpm,INT,Usage of the GPU
guestMemoryUsagePpm,INT,None
hypervisorAvgIoLatencyMicros,INT,None
hypervisorCpuReadyTimePpm,INT,Hypervisor CPU ready time
hypervisorCpuUsagePpm,INT,Percent of CPU used by the hypervisor.
hypervisorIoBandwidthKbps,INT,None
hypervisorMemoryBalloonReclaimTargetBytes,INT,Memory Swap Out Rate
hypervisorMemoryBalloonReclaimedBytes,INT,Memory Balloon Bytes
hypervisorMemoryUsagePpm,INT,Hypervisor Memory Usage percentage
hypervisorNumIo,INT,None
hypervisorNumIops,INT,None
hypervisorNumReadIo,INT,None
hypervisorNumReadIops,INT,None
hypervisorNumReceivePacketsDropped,INT,Network Receive Packets Dropped
hypervisorNumReceivedBytes,INT,Write data transferred in KB/second from the Storage Controller.
hypervisorNumTransmitPacketsDropped,INT,Network Transmit Packets Dropped
hypervisorNumTransmittedBytes,INT,Write data transferred per second in KB/second.
hypervisorNumWriteIo,INT,None
hypervisorNumWriteIops,INT,None
hypervisorReadIoBandwidthKbps,INT,None
hypervisorSwapInRateKbps,INT,Memory Swap In Rate
hypervisorSwapOutRateKbps,INT,Memory Swap Out Rate
hypervisorTimespanMicros,INT,None
hypervisorTotalIoSizeKb,INT,None
hypervisorTotalIoTimeMicros,INT,None
hypervisorTotalReadIoSizeKb,INT,None
hypervisorType,STRING,None
hypervisorVmRunningTimeUsecs,INT,None
hypervisorWriteIoBandwidthKbps,INT,None
memoryReservedBytes,INT,None
memoryUsageBytes,INT,None
memoryUsagePpm,INT,Percent of memory used by the VM.
numVcpusUsedPpm,INT,None

#* initialize variable for API client configuration
api_client_configuration = ntnx_vmm_py_client.Configuration()
api_client_configuration.host = api_server
api_client_configuration.username = username
api_client_configuration.password = secret

if secure is False:
    #! suppress warnings about insecure connections
    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
    #! suppress ssl certs verification
    api_client_configuration.verify_ssl = False

client = ntnx_vmm_py_client.ApiClient(configuration=api_client_configuration)

#* fetch vm object to figure out extId
entity_api = ntnx_vmm_py_client.VmApi(api_client=client)
query_filter = f"name eq '{vm}'"
response = entity_api.list_vms(_filter=query_filter)
vm_uuid = response.data[0].ext_id

#* fetch metrics for vm
entity_api = ntnx_vmm_py_client.StatsApi(api_client=client)
start_time = (datetime.datetime.now(datetime.timezone.utc)-datetime.timedelta(minutes=minutes_ago)).isoformat()
end_time = (datetime.datetime.now(datetime.timezone.utc)).isoformat()
response = entity_api.get_vm_stats_by_id(vm_uuid, _startTime=start_time, _endTime=end_time, _samplingInterval=sampling_interval, _statType=stat_type, _select='*')
vm_stats = [stat for stat in response.data.stats if stat.cluster is None]

#* building pandas dataframe from the retrieved data
data_points = []
for data_point in vm_stats:
    data_points.append(data_point.to_dict())
df = pd.DataFrame(data_points)
df = df.set_index('timestamp')
df.drop('_reserved', axis=1, inplace=True)
df.drop('_object_type', axis=1, inplace=True)
df.drop('_unknown_fields', axis=1, inplace=True)
df.drop('cluster', axis=1, inplace=True)
df.drop('hypervisor_type', axis=1, inplace=True)

#* building graphs
df = df.dropna(subset=['disk_usage_ppm'])
df['disk_usage'] = (df['disk_usage_ppm'] / 10000).round(2)
df = df.dropna(subset=['memory_usage_ppm'])
df['memory_usage'] = (df['memory_usage_ppm'] / 10000).round(2)
df = df.dropna(subset=['hypervisor_cpu_usage_ppm'])
df['hypervisor_cpu_usage'] = (df['hypervisor_cpu_usage_ppm'] / 10000).round(2)
df = df.dropna(subset=['hypervisor_cpu_ready_time_ppm'])
df['hypervisor_cpu_ready_time'] = (df['hypervisor_cpu_ready_time_ppm'] / 10000).round(2)

fig = make_subplots(rows=2, cols=2,
        subplot_titles=(f"{vm} Overview", f"{vm} Storage IOPS", f"{vm} Storage Bandwidth", f"{vm} Storage Latency"),
        x_title="Time")  # Shared x-axis title
# Subplot 1: Overview
y_cols1 = ["hypervisor_cpu_usage", "hypervisor_cpu_ready_time", "memory_usage", "disk_usage"]
for y_col in y_cols1:
    fig.add_trace(go.Scatter(x=df.index, y=df[y_col], hovertemplate="%{x}<br>%%{y}", name=y_col, mode='lines', legendgroup='group1'), row=1, col=1)
fig.update_yaxes(title_text="% Utilized", range=[0, 100], row=1, col=1)
# Subplot 2: Storage IOPS
y_cols2 = ["controller_num_iops", "controller_num_read_iops", "controller_num_write_iops"]
for y_col in y_cols2:
    fig.add_trace(go.Scatter(x=df.index, y=df[y_col], hovertemplate="%{x}<br>%{y} iops", name=y_col, mode='lines', legendgroup='group2'), row=1, col=2)
fig.update_yaxes(title_text="IOPS", row=1, col=2)
# Subplot 3: Storage Bandwidth
y_cols3 = ["controller_io_bandwidth_kbps", "controller_read_io_bandwidth_kbps", "controller_write_io_bandwidth_kbps"]
for y_col in y_cols3:
    fig.add_trace(go.Scatter(x=df.index, y=df[y_col], hovertemplate="%{x}<br>%{y} kbps", name=y_col, mode='lines', legendgroup='group3'), row=2, col=1)
fig.update_yaxes(title_text="Kbps", row=2, col=1)
# Subplot 4: Storage Latency
y_cols4 = ["controller_avg_io_latency_micros", "controller_avg_read_io_latency_micros", "controller_avg_write_io_latency_micros"]
for y_col in y_cols4:
    fig.add_trace(go.Scatter(x=df.index, y=df[y_col], hovertemplate="%{x}<br>%{y} usec", name=y_col, mode='lines', legendgroup='group4'), row=2, col=2)
fig.update_yaxes(title_text="Microseconds", row=2, col=2)
fig.update_layout(height=800, legend_title_text="Metric") # Shared legend title
fig.show()

def get_vm_metrics(client,vm,minutes_ago,sampling_interval,stat_type):
    '''get_vm_metrics function.
       Fetches metrics for a specified vm and generates graphs for that entity.
        Args:
            client: a v4 Python SDK client object.
            vm: a virtual machine name
            minutes_ago: integer indicating the number of minutes to get metrics for (exp: 60 would mean get the metrics for the last hour).
            sampling_interval: integer used to specify in seconds the sampling interval.
            stat_type: The operator to use while performing down-sampling on stats data. Allowed values are SUM, MIN, MAX, AVG, COUNT and LAST.
        Returns:
    '''
    #* fetch vm object to figure out extId
    entity_api = ntnx_vmm_py_client.VmApi(api_client=client)
    query_filter = f"name eq '{vm}'"
    response = entity_api.list_vms(_filter=query_filter)
    vm_uuid = response.data[0].ext_id
    
    #* fetch metrics for vm
    entity_api = ntnx_vmm_py_client.StatsApi(api_client=client)
    start_time = (datetime.datetime.now(datetime.timezone.utc)-datetime.timedelta(minutes=minutes_ago)).isoformat()
    end_time = (datetime.datetime.now(datetime.timezone.utc)).isoformat()
    response = entity_api.get_vm_stats_by_id(vm_uuid, _startTime=start_time, _endTime=end_time, _samplingInterval=sampling_interval, _statType=stat_type, _select='*')
    vm_stats = [stat for stat in response.data.stats if stat.cluster is None]
        
    #* building pandas dataframe from the retrieved data
    data_points = []
    for data_point in vm_stats:
        data_points.append(data_point.to_dict())
    df = pd.DataFrame(data_points)
    df = df.set_index('timestamp')
    df.drop('_reserved', axis=1, inplace=True)
    df.drop('_object_type', axis=1, inplace=True)
    df.drop('_unknown_fields', axis=1, inplace=True)
    df.drop('cluster', axis=1, inplace=True)
    df.drop('hypervisor_type', axis=1, inplace=True)

    #* building graphs
    df = df.dropna(subset=['disk_usage_ppm'])
    df['disk_usage'] = (df['disk_usage_ppm'] / 10000).round(2)
    df = df.dropna(subset=['memory_usage_ppm'])
    df['memory_usage'] = (df['memory_usage_ppm'] / 10000).round(2)
    df = df.dropna(subset=['hypervisor_cpu_usage_ppm'])
    df['hypervisor_cpu_usage'] = (df['hypervisor_cpu_usage_ppm'] / 10000).round(2)
    df = df.dropna(subset=['hypervisor_cpu_ready_time_ppm'])
    df['hypervisor_cpu_ready_time'] = (df['hypervisor_cpu_ready_time_ppm'] / 10000).round(2)

    fig = make_subplots(rows=2, cols=2,
            subplot_titles=(f"{vm} Overview", f"{vm} Storage IOPS", f"{vm} Storage Bandwidth", f"{vm} Storage Latency"),
            x_title="Time")  # Shared x-axis title
    # Subplot 1: Overview
    y_cols1 = ["hypervisor_cpu_usage", "hypervisor_cpu_ready_time", "memory_usage", "disk_usage"]
    for y_col in y_cols1:
        fig.add_trace(go.Scatter(x=df.index, y=df[y_col], hovertemplate="%{x}<br>%%{y}", name=y_col, mode='lines', legendgroup='group1'), row=1, col=1)
    fig.update_yaxes(title_text="% Utilized", range=[0, 100], row=1, col=1)
    # Subplot 2: Storage IOPS
    y_cols2 = ["controller_num_iops", "controller_num_read_iops", "controller_num_write_iops"]
    for y_col in y_cols2:
        fig.add_trace(go.Scatter(x=df.index, y=df[y_col], hovertemplate="%{x}<br>%{y} iops", name=y_col, mode='lines', legendgroup='group2'), row=1, col=2)
    fig.update_yaxes(title_text="IOPS", row=1, col=2)
    # Subplot 3: Storage Bandwidth
    y_cols3 = ["controller_io_bandwidth_kbps", "controller_read_io_bandwidth_kbps", "controller_write_io_bandwidth_kbps"]
    for y_col in y_cols3:
        fig.add_trace(go.Scatter(x=df.index, y=df[y_col], hovertemplate="%{x}<br>%{y} kbps", name=y_col, mode='lines', legendgroup='group3'), row=2, col=1)
    fig.update_yaxes(title_text="Kbps", row=2, col=1)
    # Subplot 4: Storage Latency
    y_cols4 = ["controller_avg_io_latency_micros", "controller_avg_read_io_latency_micros", "controller_avg_write_io_latency_micros"]
    for y_col in y_cols4:
        fig.add_trace(go.Scatter(x=df.index, y=df[y_col], hovertemplate="%{x}<br>%{y} usec", name=y_col, mode='lines', legendgroup='group4'), row=2, col=2)
    fig.update_yaxes(title_text="Microseconds", row=2, col=2)
    fig.update_layout(height=800, legend_title_text="Metric") # Shared legend title
    fig.show()

#* initialize variable for API client configuration
api_client_configuration = ntnx_vmm_py_client.Configuration()
api_client_configuration.host = api_server
api_client_configuration.username = username
api_client_configuration.password = secret

if secure is False:
    #! suppress warnings about insecure connections
    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
    #! suppress ssl certs verification
    api_client_configuration.verify_ssl = False

client = ntnx_vmm_py_client.ApiClient(configuration=api_client_configuration)

with tqdm.tqdm(total=len(vms), desc="Processing VMs") as progress_bar:
    with ThreadPoolExecutor(max_workers=10) as executor:
        futures = [executor.submit(
                get_vm_metrics,
                client=client,
                vm=vm,
                minutes_ago=minutes_ago,
                sampling_interval=sampling_interval,
                stat_type=stat_type
            ) for vm in vms]
        for future in as_completed(futures):
            try:
                entities = future.result()
            except Exception as e:
                print(f"{PrintColors.WARNING}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [WARNING] Task failed: {e}{PrintColors.RESET}")
            finally:
                progress_bar.update(1)

for column in df.columns:
    df[column].to_csv(f"{vm}_{column}.csv", index=True)

if __name__ == '__main__':
    # * parsing script arguments
    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument("-p", "--prism", help="prism server.")
    parser.add_argument("-u", "--username", default='admin', help="username for prism server.")
    parser.add_argument("-s", "--secure", default=False, action=argparse.BooleanOptionalAction, help="Control SSL certs verification.")
    parser.add_argument("-sh", "--show", action=argparse.BooleanOptionalAction, help="Show available entity types and metrics.")
    parser.add_argument("-g", "--graph", action=argparse.BooleanOptionalAction, help="Indicate you want graphs to be generated. Defaults to True.")
    parser.add_argument("-e", "--export", action=argparse.BooleanOptionalAction, help="Indicate you want csv exports to be generated (1 csv file per metric for each vm). Defaults to False.")
    parser.add_argument("-v", "--vm", type=str, help="Comma separated list of VM names you want to process.")
    parser.add_argument("-c", "--csv", type=str, help="Path and name of csv file with vm names (header: vm_name and then one vm name per line).")
    parser.add_argument("-t", "--time", type=int, default=5, help="Integer used to specify how many minutes ago you want to collect metrics for (defaults to 5 minutes ago).")
    parser.add_argument("-i", "--interval", type=int, default=30, help="Integer used to specify in seconds the sampling interval (defaults to 30 seconds).")
    parser.add_argument("-st", "--stat_type", default="AVG", choices=["AVG","MIN","MAX","LAST","SUM","COUNT"], help="The operator to use while performing down-sampling on stats data. Allowed values are SUM, MIN, MAX, AVG, COUNT and LAST. Defaults to AVG")
    args = parser.parse_args()

    # * check for password (we use keyring python module to access the workstation operating system password store in an "ntnx" section)
    print(f"{PrintColors.OK}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [INFO] Trying to retrieve secret for user {args.username} from the password store.{PrintColors.RESET}")
    pwd = keyring.get_password("ntnx",args.username)
    if not pwd:
        try:
            pwd = getpass.getpass()
            keyring.set_password("ntnx",args.username,pwd)
        except Exception as error:
            print(f"{PrintColors.FAIL}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [ERROR] {error}.{PrintColors.RESET}")
            exit(1)

    if args.show is True:
        target_vms = None
    elif args.csv:
        data=pd.read_csv(args.csv)
        target_vms = data['vm_name'].tolist()
    elif args.vm:
        target_vms = args.vm.split(',')

    main(api_server=args.prism,username=args.username,secret=pwd,secure=args.secure,show=args.show,vms=target_vms,minutes_ago=args.time,sampling_interval=args.interval,stat_type=args.stat_type,graph=args.graph,csv_export=args.export)

""" gets misc entities list from Prism Central using v4 API and python SDK

    Args:
        prism: The IP or FQDN of Prism.
        username: The Prism user name.
        secure: True or False to control SSL certs verification.

    Returns:
        html and excel report files.
"""

#region #*IMPORT
from concurrent.futures import ThreadPoolExecutor, as_completed

import math
import time
import datetime
import argparse
import getpass

from humanfriendly import format_timespan

import urllib3
import pandas as pd
import datapane
import keyring
import tqdm

import ntnx_vmm_py_client
import ntnx_clustermgmt_py_client
import ntnx_networking_py_client
import ntnx_prism_py_client
import ntnx_iam_py_client
#endregion #*IMPORT

#region #*CLASS
class PrintColors:
    """Used for colored output formatting.
    """
    OK = '\033[92m' #GREEN
    SUCCESS = '\033[96m' #CYAN
    DATA = '\033[097m' #WHITE
    WARNING = '\033[93m' #YELLOW
    FAIL = '\033[91m' #RED
    STEP = '\033[95m' #PURPLE
    RESET = '\033[0m' #RESET COLOR
#endregion #*CLASS

#region #*FUNCTIONS


def fetch_entities(client,module,entity_api,function,page,limit=50):
    '''fetch_entities function.
        Args:
            client: a v4 Python SDK client object.
            module: name of the v4 Python SDK module to use.
            entity_api: name of the entity API to use.
            function: name of the function to use.
            page: page number to fetch.
            limit: number of entities to fetch.
        Returns:
    '''
    entity_api_module = getattr(module, entity_api)
    entity_api = entity_api_module(api_client=client)
    list_function = getattr(entity_api, function)
    response = list_function(_page=page,_limit=limit)
    return response


#more on main later


#endregion #*FUNCTIONS

if __name__ == '__main__':
    # * parsing script arguments
    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument("-p", "--prism", help="prism server.")
    parser.add_argument("-u", "--username", default='admin', help="username for prism server.")
    parser.add_argument("-s", "--secure", default=False, help="True of False to control SSL certs verification.")
    args = parser.parse_args()

    # * check for password (we use keyring python module to access the workstation operating system password store in an "ntnx" section)
    print(f"{PrintColors.OK}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [INFO] Trying to retrieve secret for user {args.username} from the password store.{PrintColors.RESET}")
    pwd = keyring.get_password("ntnx",args.username)
    if not pwd:
        try:
            pwd = getpass.getpass()
            keyring.set_password("ntnx",args.username,pwd)
        except Exception as error:
            print(f"{PrintColors.FAIL}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [ERROR] {error}.{PrintColors.RESET}")
            exit(1)
    main(api_server=args.prism,username=args.username,secret=pwd,secure=args.secure)

parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)

parser.add_argument("-p", "--prism", help="prism server.")
parser.add_argument("-u", "--username", default='admin', help="username for prism server.")
parser.add_argument("-s", "--secure", default=False, help="True of False to control SSL certs verification.")

args = parser.parse_args()

pwd = keyring.get_password("ntnx",args.username)

if not pwd:
	try:
		pwd = getpass.getpass()
		keyring.set_password("ntnx",args.username,pwd)
	except Exception as error:
		print(f"{PrintColors.FAIL}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [ERROR] {error}.{PrintColors.RESET}")
		exit(1)

pwd = getpass.getpass()

keyring.set_password("ntnx",args.username,pwd)

keyring del ntnx <username>

def main(api_server,username,secret,secure=False):
    '''main function.
        Args:
            api_server: IP or FQDN of the REST API server.
            username: Username to use for authentication.
            secret: Secret for the username.
            secure: indicates if certs should be verified.
        Returns:
            html and excel report files.
    '''

    start_time = time.time()
    limit=100

#region #?clusters
    #* initialize variable for API client configuration
    api_client_configuration = ntnx_clustermgmt_py_client.Configuration()
    api_client_configuration.host = api_server
    api_client_configuration.username = username
    api_client_configuration.password = secret

    if secure is False:
        #! suppress warnings about insecure connections
        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
        #! suppress ssl certs verification
        api_client_configuration.verify_ssl = False

    #* getting list of clusters
    client = ntnx_clustermgmt_py_client.ApiClient(configuration=api_client_configuration)
    entity_api = ntnx_clustermgmt_py_client.ClustersApi(api_client=client)
    print(f"{PrintColors.OK}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [INFO] Fetching Clusters...{PrintColors.RESET}")
    entity_list=[]
    response = entity_api.list_clusters(_page=0,_limit=1)
    total_available_results=response.metadata.total_available_results
    page_count = math.ceil(total_available_results/limit)
    with tqdm.tqdm(total=page_count, desc="Fetching entity pages") as progress_bar:
        with ThreadPoolExecutor(max_workers=10) as executor:
            futures = [executor.submit(
                    fetch_entities,
                    module=ntnx_clustermgmt_py_client,
                    entity_api='ClustersApi',
                    client=client,
                    function='list_clusters',
                    page=page_number,
                    limit=limit
                ) for page_number in range(0, page_count, 1)]
            for future in as_completed(futures):
                try:
                    entities = future.result()
                    entity_list.extend(entities.data)
                except Exception as e:
                    print(f"{PrintColors.WARNING}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [WARNING] Task failed: {e}{PrintColors.RESET}")
                finally:
                    progress_bar.update(1)
    cluster_list = entity_list

    #* format output
    print(f"{PrintColors.OK}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [INFO] Processing {len(entity_list)} entities...{PrintColors.RESET}")
    cluster_list_output = []
    for entity in cluster_list:
        if 'PRISM_CENTRAL' in entity.config.cluster_function:
            continue
        entity_output = {
            'name': entity.name,
            'ext_id': entity.ext_id,
            'incarnation_id': entity.config.incarnation_id,
            'is_available': entity.config.is_available,
            'operation_mode': entity.config.operation_mode,
            'redundancy_factor': entity.config.redundancy_factor,
            'domain_awareness_level': entity.config.fault_tolerance_state.domain_awareness_level,
            'current_max_fault_tolerance': entity.config.fault_tolerance_state.current_max_fault_tolerance,
            'desired_max_fault_tolerance': entity.config.fault_tolerance_state.desired_max_fault_tolerance,
            'upgrade_status': entity.upgrade_status,
            'vm_count': entity.vm_count,
            'inefficient_vm_count': entity.inefficient_vm_count,
            'cluster_arch': entity.config.cluster_arch,
            'cluster_function': entity.config.cluster_function,
            'hypervisor_types': entity.config.hypervisor_types,
            'is_password_remote_login_enabled': entity.config.is_password_remote_login_enabled,
            'is_remote_support_enabled': entity.config.is_remote_support_enabled,
            'pulse_enabled': entity.config.pulse_status.is_enabled,
            'timezone': entity.config.timezone,
            'ncc_version': next(iter({ software.version for software in entity.config.cluster_software_map if software.software_type == "NCC" })),
            'aos_full_version': entity.config.build_info.full_version,
            'aos_commit_id': entity.config.build_info.short_commit_id,
            'aos_version': entity.config.build_info.version,
            'is_segmentation_enabled': entity.network.backplane.is_segmentation_enabled,
            'external_address_ipv4': entity.network.external_address.ipv4.value,
            'external_data_service_ipv4': entity.network.external_data_service_ip.ipv4.value,
            'external_subnet': entity.network.external_subnet,
            'name_server_ipv4_list': list({ name_server.ipv4.value for name_server in entity.network.name_server_ip_list}),
            'ntp_server_list': "",
            'number_of_nodes': entity.nodes.number_of_nodes,
        }
        if "fqdn" in entity.network.ntp_server_ip_list:
            entity_output['ntp_server_list'] = list({ ntp_server.fqdn.value for ntp_server in entity.network.ntp_server_ip_list})
        elif "ipv4" in entity.network.ntp_server_ip_list:
            entity_output['ntp_server_list'] = list({ ntp_server.ipv4.value for ntp_server in entity.network.ntp_server_ip_list})

        cluster_list_output.append(entity_output)
#endregion #?clusters

api_client_configuration = ntnx_clustermgmt_py_client.Configuration()
api_client_configuration.host = api_server
api_client_configuration.username = username
api_client_configuration.password = secret

main(api_server=args.prism,username=args.username,secret=pwd,secure=args.secure)

if secure is False:
	#! suppress warnings about insecure connections
	urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
	#! suppress ssl certs verification
	api_client_configuration.verify_ssl = False

client = ntnx_clustermgmt_py_client.ApiClient(configuration=api_client_configuration)
entity_api = ntnx_clustermgmt_py_client.ClustersApi(api_client=client)

entity_list=[]

response = entity_api.list_clusters(_page=0,_limit=1)
total_available_results=response.metadata.total_available_results
page_count = math.ceil(total_available_results/limit)

with tqdm.tqdm(total=page_count, desc="Fetching entity pages") as progress_bar:
	with ThreadPoolExecutor(max_workers=10) as executor:
		futures = [executor.submit(
				fetch_entities,
				module=ntnx_clustermgmt_py_client,
				entity_api='ClustersApi',
				client=client,
				function='list_clusters',
				page=page_number,
				limit=limit
			) for page_number in range(0, page_count, 1)]
		for future in as_completed(futures):
			try:
				entities = future.result()
				entity_list.extend(entities.data)
			except Exception as e:
				print(f"{PrintColors.WARNING}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [WARNING] Task failed: {e}{PrintColors.RESET}")
			finally:
				progress_bar.update(1)

entity_list.extend(entities.data)

progress_bar.update(1)

cluster_list = entity_list

cluster_list_output = []

for entity in cluster_list:
	if 'PRISM_CENTRAL' in entity.config.cluster_function:
		continue
	entity_output = {
		'name': entity.name,
		'ext_id': entity.ext_id,
		'incarnation_id': entity.config.incarnation_id,
		'is_available': entity.config.is_available,
		'operation_mode': entity.config.operation_mode,
		'redundancy_factor': entity.config.redundancy_factor,
		'domain_awareness_level': entity.config.fault_tolerance_state.domain_awareness_level,
		'current_max_fault_tolerance': entity.config.fault_tolerance_state.current_max_fault_tolerance,
		'desired_max_fault_tolerance': entity.config.fault_tolerance_state.desired_max_fault_tolerance,
		'upgrade_status': entity.upgrade_status,
		'vm_count': entity.vm_count,
		'inefficient_vm_count': entity.inefficient_vm_count,
		'cluster_arch': entity.config.cluster_arch,
		'cluster_function': entity.config.cluster_function,
		'hypervisor_types': entity.config.hypervisor_types,
		'is_password_remote_login_enabled': entity.config.is_password_remote_login_enabled,
		'is_remote_support_enabled': entity.config.is_remote_support_enabled,
		'pulse_enabled': entity.config.pulse_status.is_enabled,
		'timezone': entity.config.timezone,
		'ncc_version': next(iter({ software.version for software in entity.config.cluster_software_map if software.software_type == "NCC" })),
		'aos_full_version': entity.config.build_info.full_version,
		'aos_commit_id': entity.config.build_info.short_commit_id,
		'aos_version': entity.config.build_info.version,
		'is_segmentation_enabled': entity.network.backplane.is_segmentation_enabled,
		'external_address_ipv4': entity.network.external_address.ipv4.value,
		'external_data_service_ipv4': entity.network.external_data_service_ip.ipv4.value,
		'external_subnet': entity.network.external_subnet,
		'name_server_ipv4_list': list({ name_server.ipv4.value for name_server in entity.network.name_server_ip_list}),
		'ntp_server_list': "",
		'number_of_nodes': entity.nodes.number_of_nodes,
	}
	if "fqdn" in entity.network.ntp_server_ip_list:
		entity_output['ntp_server_list'] = list({ ntp_server.fqdn.value for ntp_server in entity.network.ntp_server_ip_list})
	elif "ipv4" in entity.network.ntp_server_ip_list:
		entity_output['ntp_server_list'] = list({ ntp_server.ipv4.value for ntp_server in entity.network.ntp_server_ip_list})

	cluster_list_output.append(entity_output)

#region #?html report
    #* exporting to html
    html_file_name = f"{api_server}_get_pc_report.html"
    print(f"{PrintColors.OK}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [INFO] Exporting results to file {html_file_name}.{PrintColors.RESET}")

    vm_df = pd.DataFrame(vm_list_output)
    cluster_df = pd.DataFrame(cluster_list_output)
    host_df = pd.DataFrame(host_list_output)
    storage_container_df = pd.DataFrame(storage_container_list_output)
    subnet_df = pd.DataFrame(subnet_list_output)
    category_df = pd.DataFrame(category_list_output)
    user_df = pd.DataFrame(user_list_output)


    datapane_app = datapane.App(
        datapane.Select(
        datapane.DataTable(vm_df,label="vms"),
        datapane.DataTable(cluster_df,label="clusters"),
        datapane.DataTable(host_df,label="hosts"),
        datapane.DataTable(storage_container_df,label="storage_containers"),
        datapane.DataTable(subnet_df,label="subnets"),
        datapane.DataTable(category_df,label="categories"),
        datapane.DataTable(user_df,label="users"),
        )
    )
    datapane_app.save(html_file_name)
#endregion #?html report

#region #?excel spreadsheet
    excel_file_name = f"{api_server}_get_pc_report.xlsx"
    print(f"{PrintColors.OK}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [INFO] Exporting results to file {excel_file_name}.{PrintColors.RESET}")
    data = {'vms': vm_list_output, 'clusters': cluster_list_output, 'hosts': host_list_output, 'storage_containers': storage_container_list_output, 'subnets': subnet_list_output, 'categories': category_list_output, 'users': user_list_output}

    with pd.ExcelWriter(excel_file_name, engine='xlsxwriter') as writer:
        for sheet_name, df_data in data.items():
            df = pd.DataFrame(df_data)  # Create a DataFrame for each dictionary
            if sheet_name == 'users':
                df['created_time'] = df['created_time'].dt.tz_localize(None)
                df['last_updated_time'] = df['last_updated_time'].dt.tz_localize(None)
                df['last_login_time'] = df['last_login_time'].dt.tz_localize(None)
            df.to_excel(writer, sheet_name=sheet_name, index=False)  # index=False to avoid row numbers
#endregion #?excel spreadsheet

end_time = time.time()
elapsed_time = end_time - start_time
print(f"{PrintColors.STEP}{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [SUM] Process completed in {format_timespan(elapsed_time)}{PrintColors.RESET}")

# step 1 of 5: import the module
import ntnx_vmm_py_client

# step 2 of 5: create an API client configuration object and set key attributes
api_client_configuration = ntnx_vmm_py_client.Configuration()
api_client_configuration.host = api_server 
api_client_configuration.username = username
api_client_configuration.password = secret
api_client_configuration.verify_ssl = False

# step 3 of 5: use the API client configuration to create an API client object
api_client = ntnx_vmm_py_client.ApiClient(configuration=api_client_configuration)

# step 4 of 5: create an instance of the API client by connecting it to a specific submodule
api_instance_vm = ntnx_vmm_py_client.api.VmApi(api_client=api_client)

# step 5 of 5: use the API client instance to make a call to a specific API endpoint and get or post data
vm_list = api_instance_vm.list_vms()

https://{{pc_ip}}:9440/api/vmm/v4.0/ahv/config/vms?$page=0&$limit=100

import math

client = ntnx_vmm_py_client.ApiClient(configuration=api_client_configuration)
entity_api = ntnx_vmm_py_client.VmApi(api_client=client)
LIMIT = 100

response = entity_api.list_vms(_page=0,_limit=1)

total_available_results=response.metadata.total_available_results
page_count = math.ceil(total_available_results/LIMIT)

from concurrent.futures import ThreadPoolExecutor, as_completed
import tqdm

def fetch_entities(client,module,entity_api,function,page,limit):
    entity_api_module = getattr(module, entity_api)
    entity_api = entity_api_module(api_client=client)
    list_function = getattr(entity_api, function)
    response = list_function(_page=page,_limit=limit)
    return response

entity_list=[]
LIMIT = 100

with tqdm.tqdm(total=page_count, desc="Fetching entity pages") as progress_bar:    
    with ThreadPoolExecutor(max_workers=10) as executor:
        futures = [executor.submit(
                fetch_entities,
                module=ntnx_vmm_py_client,
                entity_api='VmApi',
                client=client,
                function='list_vms',
                page=page_number,
                limit=LIMIT
            ) for page_number in range(0, page_count, 1)]
        for future in as_completed(futures):
            try:
                entities = future.result()
                entity_list.extend(entities.data)
            except Exception as e:
                print(f"{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [WARNING] Task failed: {e}")
            finally:
                progress_bar.update(1)

client = ntnx_clustermgmt_py_client.ApiClient(configuration=api_client_configuration)

entity_api = ntnx_clustermgmt_py_client.ClustersApi(api_client=client)
entity_list=[]
LIMIT = 100

response = entity_api.list_clusters(_page=0,_limit=1)

total_available_results=response.metadata.total_available_results<br>page_count = math.ceil(total_available_results/LIMIT)
with tqdm.tqdm(total=page_count, desc="Fetching entity pages") as progress_bar:
        with ThreadPoolExecutor(max_workers=10) as executor:
                futures = [executor.submit(
                        fetch_entities,
                        module=ntnx_clustermgmt_py_client,
                        entity_api='ClustersApi',
                        client=client,
                        function='list_clusters',
                        page=page_number,
                        limit=LIMIT
                    ) for page_number in range(0, page_count, 1)]
                for future in as_completed(futures):
                    try:
                        entities = future.result()
                        entity_list.extend(entities.data)
                    except Exception as e:
                        print(f"{(datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')} [WARNING] Task failed: {e}")
                    finally:
                        progress_bar.update(1)