#!/usr/bin/perl -w
##################################################################
# Author: William Lam
# Email: william2003[at]gmail[dot]com
# 01/26/2009
# http://www.engineering.ucsb.edu/~duonglt/vmware/
##################################################################
use strict;
use warnings;
use Math::BigInt;
use Tie::File;
use Getopt::Long;
use VMware::VIRuntime;
use VMware::VILib;

################################
# disk consumption warnings
################################
# yellow < 30 %
my $yellow_warn = 30;

# orange < 15 %
my $orange_warn = 15;

# red < 10%
my $red_warn = 10;

########### DO NOT MODIFY PAST HERE ###########

################################
# VERSION
################################
my $version = "v0.4";

################################
# DEMO MODE
# 0 = no, 1 = yes
################################
my $enable_demo_mode = 0;

################
#GLOBAL VARS
################
my $host_type;
my $host_view;
my $host_views;
my $cluster_view;
my $cluster_views;
my $cluster_count = 0;
my $report_name;
my @snapshot_vms = ();
my @connected_cdrom_vms = ();
my @connected_floppy_vms = ();
my @rdm_vms = ();
my @npiv_vms = ();
my %net_vms = ();
my %vms_storage = ();
my %vms_disks = ();
my $execute_flag = 0;
my $start_time;
my $end_time;
my $run_time;
my $my_time;
my @jump_tags = ();
my %cdp_enabled = ();
my @hba_list = ();
my @nic_list = ();
my @hosts_seen = ();

my %opts = (
	cluster => {
      	type => "=s",
      	help => "The name of a vCenter cluster",
      	required => 0,
   	},
   	type => {
      	type => "=s",
      	help => "Type: [vcenter|cluster|host]\n",
      	required => 1,
   	},
	report => {
	type => "=s",
	help => "The name of the report to output",
	required => 0,
	},
);
# validate options, and connect to the server
Opts::add_options(%opts);

# validate options, and connect to the server
Opts::parse();
Opts::validate();
Util::connect();

############################
# PARSE COMMANDLINE OPTIONS
#############################
if (Opts::option_is_set ('type')) {
	$host_type = Opts::get_option('type');

	####################
	# SINGLE ESX HOST
	####################
	if( ($host_type eq "host") && (!Opts::option_is_set('cluster')) ) {
		$host_view = Vim::find_entity_views(view_type => 'HostSystem');
		if (!$host_view) {
			die "ESX/ESXi host was not found\n";
		}
	}
	#####################
	# vCENTER + CLUSTER
	#####################
	elsif( $host_type eq "cluster" ) {
		if ( Opts::option_is_set('cluster') ) {
			my $cluster_name = Opts::get_option('cluster');
			$cluster_view = Vim::find_entity_view(view_type => 'ClusterComputeResource',filter => { name => $cluster_name });

			if(!$cluster_view) {
				die "\"$cluster_name\" was not found\n";
			}
		}
		else {
			Fail("\n--cluster parameter required with the name of a valid vCenter Cluster\n\n");
		}
	}
	##################
	# vCENTER ALL
	##################
	elsif( ($host_type eq "vcenter") && (!Opts::option_is_set('cluster')) ) {
		$cluster_views = Vim::find_entity_views(view_type => 'ClusterComputeResource');
		Fail ("No clusters found.\n") unless (@$cluster_views);
	}
	#if report name is not specified, default output
	if (Opts::option_is_set ('report')) {
		$report_name = Opts::get_option('report');
	}
	else {
		$report_name = "report.html";
	}
}

### CODE START ###

#################################
# PRINT HTML HEADER/CSS
#################################
printStartHeader();

#########################################
# PRINT vCENTER or HOST BUILD/SUMMARY 
#########################################
printBuildSummary();

#########################################
# PRINT vCENTER INFO
#########################################
if ($host_type eq 'vcenter') {
	foreach my $cluster (@$cluster_views) {
		$cluster_count += 1;
		printClusterSummary($cluster);	
		my $hosts = Vim::get_views (mo_ref_array => $cluster->host);
		if(@$hosts) {
			printHostHardwareInfo($hosts);
			printHostLun($hosts);
			printHostDatastoreInfo($hosts);
			printHostPortgroup($hosts);
			printHostVM($hosts);
			printVMDatastore();
			printVMNetwork();
			printVMSnapshot();
			printVMNPIV();
			printVMRDM();
			printVMCDrom();
			printVMFloppy();
			cleanUp();
		}
	}
}
#########################################
# PRINT SPECIFIC CLUSTER INFO
#########################################
elsif ($host_type eq 'cluster') {
	$cluster_count += 1;
	printClusterSummary($cluster_view);
	my $hosts = Vim::get_views (mo_ref_array => $cluster_view->host);
	if(@$hosts) {
		printHostHardwareInfo($hosts);
		printHostLun($hosts);
		printHostDatastoreInfo($hosts);
		printHostPortgroup($hosts);
		printHostVM($hosts);
		printVMDatastore();
		printVMNetwork();
        	printVMSnapshot();
		printVMNPIV();
        	printVMRDM();
        	printVMCDrom();
		printVMFloppy();
		cleanUp();
	}
}
#########################################
# PRINT SINGLE HOST INFO
#########################################
else {
	printHostHardwareInfo($host_view);
	printHostLun($host_view);
	printHostDatastoreInfo($host_view);
	printHostPortgroup($host_view);
	printHostVM($host_view);
	printVMDatastore();
        printVMNetwork();
        printVMSnapshot();
	printVMNPIV();
        printVMRDM();
        printVMCDrom();
	printVMFloppy();
	cleanUp();
}

#################################
# CLOSE HTML REPORT
#################################
printCloseHeader();

Util::disconnect();

### CODE END ###

###########################
#
# HELPER FUNCTIONS 
#
###########################

sub printVMNPIV {
        ###########################
        # PRINT NPIV INFO
        ###########################
        if(@npiv_vms) {
                my $npiv_count = $#npiv_vms;
                $npiv_count += 1;
		push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#VM(s) w/NPIV enabled-$cluster_count\">VM(s) w/NPIV enabled</a><br>";
		print REPORT_OUTPUT "<a name=\"VM(s) w/NPIV enabled-$cluster_count\"></a>";
                print REPORT_OUTPUT "<H3>$npiv_count VM(s) w/NPIV enabled:</H3>\n";
                print REPORT_OUTPUT "<table border=1>\n";
                print REPORT_OUTPUT "<tr><th>VM</th><th>NPIV NODE WWN</th><th>NPIV PORT WWN</th><th>GENERATED FROM</th></tr>";
                foreach (@npiv_vms) {
                        print REPORT_OUTPUT "<tr>",$_,"</tr>";
                }
                print REPORT_OUTPUT "</table>\n";
        }
        @npiv_vms = ();
}

sub printVMSnapshot {
        ###########################
        # PRINT SNAPSHOT INFO
        ###########################
        if(@snapshot_vms) {
                my $snap_count = $#snapshot_vms;
                $snap_count += 1;
		push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#VM(s) w/Snapshot(s)-$cluster_count\">VM(s) w/Snapshot(s)</a><br>";
		print REPORT_OUTPUT "<a name=\"VM(s) w/Snapshot(s)-$cluster_count\"></a>";
                print REPORT_OUTPUT "<H3>$snap_count VM(s) w/Snapshot(s):</H3>\n";
                print REPORT_OUTPUT "<table border=1>\n";
                print REPORT_OUTPUT "<tr><th>VM</th><th>SNAPSHOT NAME</th><th>SNAPSHOT DESC</th><th>CREATED</th><th>STATE</th><th>QUIESCED</th></tr>";
                foreach (@snapshot_vms) {
                        print REPORT_OUTPUT "<tr>",$_,"</tr>";
                }
                print REPORT_OUTPUT "</table>\n";
        }
        @snapshot_vms = ();
}

sub printVMRDM {
        ###########################
        # PRINT RDM INFO
        ###########################
        if(@rdm_vms) {
                my $rdm_count = $#rdm_vms;
                $rdm_count += 1;
		push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#VM(s) w/RDM(s)-$cluster_count\">VM(s) w/RDM(s)</a><br>";
		print REPORT_OUTPUT "<a name=\"VM(s) w/RDM(s)-$cluster_count\"></a>";
                print REPORT_OUTPUT "<H3>$rdm_count VM(s) w/RDM(s):</H3>\n";
                print REPORT_OUTPUT "<table border=1>\n";
                print REPORT_OUTPUT "<tr><th>VM</th><th>COMPAT MODE</th><th>DEVICE</th><th>DISK MODE</th><th>LUN UUID</th><th>VIRTUAL DISK UUID</th></tr>";
                foreach (@rdm_vms) {
                        print REPORT_OUTPUT "<tr>",$_,"</tr>";
                }
                print REPORT_OUTPUT "</table>\n";
        }
        @rdm_vms = ();
}

sub printVMCDrom {
        ###########################
        # PRINT CDROM INFO
        ###########################
        if(@connected_cdrom_vms) {
                my $cdrom_count = $#connected_cdrom_vms;
                $cdrom_count += 1;
		push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#VM(s) w/connected CD-ROM(s)-$cluster_count\">VM(s) w/connected CD-ROM(s)</a><br>";
		print REPORT_OUTPUT "<a name=\"VM(s) w/connected CD-ROM(s)-$cluster_count\"></a>";
                print REPORT_OUTPUT "<H3>$cdrom_count VM(s) w/connected CD-ROM(s):</H3>\n";
                print REPORT_OUTPUT "<table border=1>\n";
                print REPORT_OUTPUT "<tr><th>VM</th></tr>";
                foreach (@connected_cdrom_vms) {
                                print REPORT_OUTPUT "<tr><td>",$_,"</td></tr>";
                }
                print REPORT_OUTPUT "</table>\n";
        }
        @connected_cdrom_vms = ();
}

sub printVMFloppy {
        ###########################
        # PRINT FLOPPY INFO
        ###########################
        if(@connected_floppy_vms) {
                my $floppy_count = $#connected_floppy_vms;
                $floppy_count += 1;
		push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#VM(s) w/connected Floppy(s)-$cluster_count\">VM(s) w/connected Floppy(s)</a><br>";
		print REPORT_OUTPUT "<a name=\"VM(s) w/connected Floppy(s)-$cluster_count\"></a>";
                print REPORT_OUTPUT "<H3>$floppy_count VM(s) w/connected Floppy(s):</H3>\n";
                print REPORT_OUTPUT "<table border=1>\n";
                print REPORT_OUTPUT "<tr><th>VM</th></tr>";
                foreach (@connected_floppy_vms) {
                                print REPORT_OUTPUT "<tr><td>",$_,"</td></tr>";
                }
                print REPORT_OUTPUT "</table>\n";
        }
        @connected_floppy_vms = ();
}

sub printVMNetwork {
        ####################################
        # PRINT VM NETWORK SUMMARY
        ####################################
        if(%net_vms) {
		push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#VM(s) Network Summary-$cluster_count\">VM(s) Network Summary</a><br>";
		print REPORT_OUTPUT "<a name=\"VM(s) Network Summary-$cluster_count\"></a>";
                print REPORT_OUTPUT "<H3>VM(s) Network Summary:</H3>\n";
                print REPORT_OUTPUT "<table border=1>\n";
                print REPORT_OUTPUT "<tr><th>VM</th><th>IP(s)</th><th>MAC ADDRESS</th><th>PORTGROUP</th><th>CONNECTED</th></tr>";
                foreach ( sort keys %net_vms ) {
                        my $vm_net = $net_vms{$_};
                        print REPORT_OUTPUT "<tr><td>",$_,"</td>",$vm_net,"</tr>\n";
                }
                print REPORT_OUTPUT "</table>\n";
        }
        %net_vms = ();
}

sub printVMDatastore {
	####################################
        # PRINT VM DISK/DATASTORE SUMMARY
        ####################################
        if(%vms_storage) {
		push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#VM(s) Storage Summary-$cluster_count\">VM(s) Storage Summary</a><br>";
		print REPORT_OUTPUT "<a name=\"VM(s) Storage Summary-$cluster_count\"></a>";
                print REPORT_OUTPUT "<H3>VM(s) Storage Summary:</H3>\n";
		print REPORT_OUTPUT "<table border=1><tr><td bgcolor=\"#CCCCCC\"><b>COLOR LEGEND</b></td><td bgcolor=\"yellow\"><b>YELLOW < $yellow_warn %</b></td><td bgcolor=\"orange\"><b>ORANGE < $orange_warn %</b></td><td bgcolor=\"red\"><b>RED < $red_warn %</b></td></tr></table>";
                print REPORT_OUTPUT "<table border=1>\n";
                print REPORT_OUTPUT "<tr><th>VM</th><th>DATASTORE</th><th><table border=1><tr><td><b>DISK INFO</b></td><td><b>FREE SPACE</b></td><td><b>CAPACITY</b></td><td><b>% FREE</b></td></tr></table></th></tr>";
                foreach ( sort keys %vms_storage ) {
                        my $vm_ds = $vms_storage{$_};
                        my $vm_disk = $vms_disks{$_};
                        if(!$vm_disk) {
                                $vm_disk = "<td>not available</td>";
                        }
                        print REPORT_OUTPUT "<tr><td>",$_,"</td><td>",$vm_ds,"</td>",$vm_disk,"</tr>\n";
                }
                print REPORT_OUTPUT "</table>\n";
        }
        %vms_storage = ();
}

sub printHostVM {
	my ($local_hosts) = @_;
        ###########################
        # PRINT VM SUMMARY
        ###########################
        my $seen_vm = 0;
	push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#Virtual Machines-$cluster_count\">Virtual Machines</a><br>";
	print REPORT_OUTPUT "<a name=\"Virtual Machines-$cluster_count\"></a>";
        print REPORT_OUTPUT "<H3>Virtual Machines:</H3>\n";
        print REPORT_OUTPUT "<table border=1>\n";
        print REPORT_OUTPUT "<tr><th>ESX&#047;ESXi HOST</th><th>VM</th><th>HOSTNAME</th><th>VM STATUS</th><th>CONNECTION STATE</th><th>POWER STATE</th><th># OF DISK(s)</th><th># OF vCPU(s)</th><th>MEM</th><th>CPU USAGE</th><th>MEM USAGE</th><th>CPU RESRV</th><th>MEM RESRV</th><th># OF vNIC(s)</th><th>VMware Tools Status</th><th>TIME SYNC w/HOST</th><th>TOOLS VER</th><th>TOOLS UPGRADE POLICY</th><th>TOOLS MOUNTED</th><th>GUEST OS</th><th>IS TEMPLATE</th></tr>\n";
        foreach my $host (@$local_hosts) {
                my $vm_views = Vim::get_views (mo_ref_array => $host->vm);
                #clear seen vms hash
                foreach my $vm (@$vm_views) { 
                        print REPORT_OUTPUT "<tr>\n";
                        my $vm_host_view =  Vim::get_view (mo_ref => $vm->runtime->host);
			if($enable_demo_mode eq 1) {
                        	print REPORT_OUTPUT "<td>HIDE ME!</td>";
				print REPORT_OUTPUT "<td>",$vm->config->name,"</td>";
				print REPORT_OUTPUT "<td>HIDE ME!</td>";
			}
			else {
				print REPORT_OUTPUT "<td>",$vm_host_view->summary->config->name,"</td>";
                        	print REPORT_OUTPUT "<td>",$vm->config->name,"</td>";
				if (defined($vm->guest->hostName)) {print REPORT_OUTPUT "<td>",$vm->guest->hostName,"</td>"; }
                        	else { print REPORT_OUTPUT "<td>UNKNOWN</td>"; }
			}
                        $seen_vm = 1;
                        my $vm_health = $vm->summary->overallStatus->val;
                        if ($vm_health eq 'green') { print REPORT_OUTPUT "<td bgcolor=\"green\">VM is OK</td>"; }
                        elsif ($vm_health eq 'red') { print REPORT_OUTPUT "<td bgcolor=\"red\">VM has a problem</td>"; }
                        elsif ($vm_health eq 'yellow') { print REPORT_OUTPUT "<td bgcolor=\"yellow\">VM<might have a problem</td>"; }
                        else { print REPORT_OUTPUT "<td bgcolor=\"gray\">UNKNOWN</td>"; }
                        print REPORT_OUTPUT "<td>",$vm->runtime->connectionState->val,"</td>";
                        print REPORT_OUTPUT "<td>",$vm->runtime->powerState->val,"</td>";
                        if (defined($vm->summary->config->numVirtualDisks)) {print REPORT_OUTPUT "<td>",$vm->summary->config->numVirtualDisks,"</td>"; }
                        else {print REPORT_OUTPUT "<td>UNKNOWN</td>"; }
                        if (defined($vm->summary->config->numCpu)) {print REPORT_OUTPUT "<td>",$vm->summary->config->numCpu,"</td>"; }
                        else {print REPORT_OUTPUT "<td>UNKNOWN</td>"; }
                        if (defined($vm->summary->config->memorySizeMB)) {print REPORT_OUTPUT "<td>",prettyPrintData($vm->summary->config->memorySizeMB,'M'),"</td>"; }
                        else {print REPORT_OUTPUT "<td>UNKNOWN</td>"; }
                        my $isTemplate = $vm->config->template;
                        if (! $isTemplate) {
                                if (defined($vm->summary->quickStats->overallCpuUsage)) {print REPORT_OUTPUT "<td>",prettyPrintData($vm->summary->quickStats->overallCpuUsage,'MHZ'),"</td>"; }
                                else {print REPORT_OUTPUT "<td>UNKNOWN</td>"; }
                                if (defined($vm->summary->quickStats->guestMemoryUsage)) {print REPORT_OUTPUT "<td>",prettyPrintData($vm->summary->quickStats->guestMemoryUsage,'M'),"</td>"; }
                                else {print REPORT_OUTPUT "<td>UNKNOWN</td>"; }
                                if (defined($vm->summary->config->cpuReservation)) {print REPORT_OUTPUT "<td>",prettyPrintData($vm->summary->config->cpuReservation,'MHZ'),"</td>"; }
                                else {print REPORT_OUTPUT "<td>UNKNOWN</td>"; }
                                if (defined($vm->summary->config->memoryReservation)) {print REPORT_OUTPUT "<td>",prettyPrintData($vm->summary->config->memoryReservation,'M'),"</td>"; }
                                else {print REPORT_OUTPUT "<td>UNKNOWN</td>"; }
                        }
                        else {
                                print REPORT_OUTPUT "<td>N/A</td>";
                                print REPORT_OUTPUT "<td>N/A</td>";
                                print REPORT_OUTPUT "<td>N/A</td>";
                                print REPORT_OUTPUT "<td>N/A</td>";

                        }
                        if (defined($vm->summary->config->numEthernetCards)) {print REPORT_OUTPUT "<td>",$vm->summary->config->numEthernetCards,"</td>"; }
                        else {print REPORT_OUTPUT "<td>UNKNOWN</td>"; }
                        if (! $isTemplate) {
                                if (defined($vm->summary->guest->toolsStatus->val)) {print REPORT_OUTPUT "<td>",$vm->summary->guest->toolsStatus->val,"</td>"; }
                                else {print REPORT_OUTPUT "<td>UNKNOWN</td>"; }
				if (defined($vm->config->tools->syncTimeWithHost)) { print REPORT_OUTPUT "<td>",($vm->config->tools->syncTimeWithHost) ? "YES" : "NO","</td>"; }
				else {print REPORT_OUTPUT "<td>UNKNOWN</td>"; }
                                if (defined($vm->config->tools->toolsVersion)) {print REPORT_OUTPUT "<td>",$vm->config->tools->toolsVersion,"</td>"; }
                                else {print REPORT_OUTPUT "<td>UNKNOWN</td>"; }
                                if (defined($vm->config->tools->toolsUpgradePolicy)) {print REPORT_OUTPUT "<td>",$vm->config->tools-> toolsUpgradePolicy,"</td>"; }
                                else {print REPORT_OUTPUT "<td>UNKNOWN</td>"; }
                                print REPORT_OUTPUT "<td>",($vm->runtime->toolsInstallerMounted) ? "YES" : "NO" ,"</td>";
                                if (defined($vm->summary->guest->guestFullName)) {print REPORT_OUTPUT "<td>",$vm->summary->guest->guestFullName,"</td>"; }
                                else {print REPORT_OUTPUT "<td>UNKNOWN</td>"; }
                        }
                        else {
                                print REPORT_OUTPUT "<td>N/A</td>";
                                print REPORT_OUTPUT "<td>N/A</td>";
                                print REPORT_OUTPUT "<td>N/A</td>";
                                print REPORT_OUTPUT "<td>N/A</td>";
                                print REPORT_OUTPUT "<td>N/A</td>";
				print REPORT_OUTPUT "<td>N/A</td>";
                        }
                        print REPORT_OUTPUT "<td>",($isTemplate) ? "YES" : "NO" ,"</td>";
                        print REPORT_OUTPUT "</tr>\n";

                        #retrieve vms w/connected CDROM/FLOPPY
                        my $devices = $vm->config->hardware->device;
                        foreach my $device (@$devices) {
                                my $device_name = $device->deviceInfo->label;
                                if ( ($device->isa('VirtualCdrom')) && ($device->connectable->connected == 1) ) {
                                        if($seen_vm eq 1) {
                                                push @connected_cdrom_vms,$vm->config->name;
                                        }
                                }
                                if ( ($device->isa('VirtualFloppy')) && ($device->connectable->connected == 1) ) {
                                        if($seen_vm eq 1) {
                                                push @connected_floppy_vms,$vm->config->name;
                                        }
                                }
                                if ( ($device->isa('VirtualDisk')) && ($device->backing->isa('VirtualDiskRawDiskMappingVer1BackingInfo')) ) {
                                        if($seen_vm eq 1) {
						my $vm_name = $vm->config->name;
						my $compat_mode = $device->backing->compatibilityMode;
						my $vmhba = $device->backing->deviceName;
						my $disk_mode = $device->backing->diskMode;
						my $lun_uuid = $device->backing->lunUuid;
						my $vm_uuid = $device->backing->uuid;
						my $rdm_string = "";
						if(!$vm_uuid) { $vm_uuid="N/A"; }
						$rdm_string="<td>$vm_name</td><td>$compat_mode</td><td>$vmhba</td><td>$disk_mode</td><td>$lun_uuid</td><td>$vm_uuid</td>";
						push @rdm_vms,$rdm_string;
                                        }
                                }
                        }

			#retrieve vms w/NPIV
			my $nwwns = $vm->config->npivNodeWorldWideName;
			my $pwwns = $vm->config->npivPortWorldWideName;
			my $n_type = $vm->config->npivWorldWideNameType;
			if( ($nwwns) && ($seen_vm eq 1) ) {
				my $npiv_string = "";
				my $n_vm = $vm->config->name;
				$npiv_string .= "<td>$n_vm</td>";
				$npiv_string .= "<td>";
				foreach (@$nwwns) {
					my $nwwn = (Math::BigInt->new($_))->as_hex();
					$nwwn =~ s/^..//;
					$nwwn = join(':', unpack('A2' x 8, $nwwn));
					if($enable_demo_mode eq 1) {
						$npiv_string .= "XX:XX:XX:XX:XX:XX:XX:XX<br>";
					}
					else {
						$npiv_string .= "$nwwn<br>";
					}
				}
				$npiv_string .= "</td><td>";
				foreach (@$pwwns) {
					my $pwwn = (Math::BigInt->new($_))->as_hex();
					$pwwn =~ s/^..//;
                                        $pwwn = join(':', unpack('A2' x 8, $pwwn));
					if($enable_demo_mode eq 1) {
						$npiv_string .= "XX:XX:XX:XX:XX:XX:XX:XX<br>";
					}
					else {
						$npiv_string .= "$pwwn<br>";
					}
                                }
				if($n_type eq 'vc') { $n_type = "Virtual Center"; }
				elsif($n_type eq 'external') { $n_type = "External Source"; }
				elsif($n_type eq 'host') { $n_type = "ESX or ESXi"; }
				$npiv_string .= "</td><td>$n_type</td>";
				push @npiv_vms,$npiv_string;
			}

                        #retrieve vms w/snapshots
                        if(defined($vm->snapshot)) {
                                if($seen_vm eq 1) {
                                        print_tree ($vm->config->name,$vm->snapshot->currentSnapshot, $vm->snapshot->rootSnapshotList);
                                }
                        }

			#retrieve datastore summary from VM
                        my $vm_datastore_view = $vm->datastore;
                        foreach (@$vm_datastore_view) {
                                if($seen_vm eq 1) {
                                        my $ds = Vim::get_view(mo_ref => $_);
                                        $vms_storage{$vm->config->name} = $ds->summary->name;
                                }
                        }

                        #retrieve disk summary from VM
                        my $disks = $vm->guest->disk;
                        my $vm_name;
                        my $disk_string = "";
                        foreach my $disk (@$disks) {
                                if($seen_vm eq 1) {
                                        $vm_name = $vm->config->name;
                                        my $vm_disk_path = $disk->diskPath;
                                        my $vm_disk_free = prettyPrintData($disk->freeSpace,'B');
                                        my $vm_disk_cap = prettyPrintData($disk->capacity,'B');
                                        my $vm_perc_free = &restrict_num_decimal_digits((($disk->freeSpace / $disk->capacity) * 100),2);
					my $perc_string = "";
					if($vm_perc_free < $red_warn) {
						$perc_string = "<td bgcolor=\"red\">".$vm_perc_free." %</td>";
					}
					elsif ($vm_perc_free < $orange_warn) {
						$perc_string = "<td bgcolor=\"orange\">".$vm_perc_free." %</td>";
                                        }
					elsif ($vm_perc_free < $yellow_warn) {
                                                $perc_string = "<td bgcolor=\"yellow\">".$vm_perc_free." %</td>";
                                        }
					else {
						$perc_string = "<td>".$vm_perc_free." %</td>";
					}
                                        $disk_string .= "<td><table border=1 width=100%><tr><td>$vm_disk_path</td><td>$vm_disk_free</td><td>$vm_disk_cap</td>$perc_string</tr></table></td>";
                                }
                        }
                        if (defined($vm_name)) {
                                $vms_disks{$vm_name} = $disk_string;
                        }

                        #retrieve network summary from VM
                        my $vm_nets = $vm->guest->net;
                        my $vm_conn_string = "";
                        my $vm_ip_string = "";
                        my $vm_mac_string = "";
                        my $vm_pg_string = "";

                        foreach my $vm_net (@$vm_nets) {
                                if($seen_vm eq 1) {
                                        $execute_flag = 1;
                                        my $net_conn = $vm_net->connected;
                                        if($net_conn eq '1') { $net_conn = "YES"; } else { $net_conn = "NO"; }
                                        $vm_conn_string .= $net_conn."<br>";
                                        my $ip_arr = $vm_net->ipAddress;
                                        foreach (@$ip_arr) {
						if($enable_demo_mode eq 1) {
                                                	$vm_ip_string .= "HIDE ME!<br>";
						}
						else {
							$vm_ip_string .= $_."<br>";
						}
                                        }
                                        my $net_mac = $vm_net->macAddress;
					my $net_pg = $vm_net->network;
                                        if($enable_demo_mode eq 1) {
                                                $net_mac .= "HIDE MY MAC!<br>";
						$vm_pg_string .= "HIDE MY PG!<br>";
                                        }
					else {
                                        	$vm_mac_string .= $net_mac."<br>";
						$vm_pg_string .= $net_pg."<br>";
					}
                                        if($vm_ip_string eq '') { $vm_ip_string="UNKNOWN<br>"; }
                                        if($vm_mac_string eq '') { $vm_mac_string="UNKNOWN<br>"; }
                                        if($vm_pg_string eq '') { $vm_pg_string="UNKNOWN<br>"; }
                                        if($vm_conn_string eq '') { $vm_conn_string="UNKNOWN<br>"; }
                                }
                        }
                        #could not retrieve network info (no VMware tools or not online)
                        if(!@$vm_nets) {
                                $vm_ip_string="UNKNOWN<br>";
                                $vm_mac_string="UNKNOWN<br>";
                                $vm_pg_string="UNKNOWN<br>";
                                $vm_conn_string="UNKNOWN<br>";
                        }
                        if($execute_flag eq 1) {
                                $net_vms{$vm->config->name} = "<td>".$vm_ip_string."</td><td>".$vm_mac_string."</td><td>".$vm_pg_string."</td><td>".$vm_conn_string."</td>";
                                $execute_flag = 0;
                        }
                        $seen_vm = 0;
                }
        }
        print REPORT_OUTPUT "</table>\n";
}

sub printHostDatastoreInfo {
	my ($local_hosts) = @_;
	###########################
        # PRINT DATASTORE SUMMARY
        ###########################
	push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#ESX/ESXi Datastore(s)-$cluster_count\">ESX/ESXi Datastore(s)</a><br>";
	print REPORT_OUTPUT "<a name=\"ESX/ESXi Datastore(s)-$cluster_count\"></a>";
        print REPORT_OUTPUT "<H3>ESX/ESXi Datastore(s):</H3>\n";
	print REPORT_OUTPUT "<table border=1><tr><td bgcolor=\"#CCCCCC\"><b>COLOR LEGEND</b></td><td bgcolor=\"yellow\"><b>YELLOW < $yellow_warn %</b></td><td bgcolor=\"orange\"><b>ORANGE < $orange_warn %</b></td><td bgcolor=\"red\"><b>RED < $red_warn %</b></td></tr></table>";
        print REPORT_OUTPUT "<table border=1>\n";
        print REPORT_OUTPUT "<tr><th>DATASTORE</th><th>CAPACITY</th><th>CONSUMED</th><th>FREE</th><th>% FREE</th><th>DS TYPE</th><th>HOST(s) NOT ACCESSIBLE TO DATASTORE</tr>";
        my @datastores_seen = ();
	my @hosts_to_datastores = ();
	my %datastore_row_info = ();
        foreach my $host (@$local_hosts) {
                my $ds_views = Vim::get_views (mo_ref_array => $host->datastore);
                foreach my $ds (sort {$a->info->name cmp $b->info->name} @$ds_views) {
			my $ds_row = "";
				#capture unique datastores seen in cluster
                                if (!grep {$_ eq $ds->info->name} @datastores_seen) {
                                        push @datastores_seen,$ds->info->name;
                                        my $perc_free;
                                        my $ds_used;
                                        my $ds_free;
					my $ds_cap;			
					my $perc_string = "";
                                        if ( ($ds->summary->freeSpace gt 0) || ($ds->summary->capacity gt 0) ) {
						$ds_cap = &restrict_num_decimal_digits($ds->summary->capacity/1024/1000,2);
						$ds_used = prettyPrintData(($ds->summary->capacity - $ds->summary->freeSpace),'B');
						$ds_free = &restrict_num_decimal_digits(($ds->summary->freeSpace/1024/1000),2);
						$perc_free = &restrict_num_decimal_digits(( 100 * $ds_free / $ds_cap),2);
	                                        if($perc_free < $red_warn) {
        	                                        $perc_string = "<td bgcolor=\"red\">".$perc_free." %</td>";
                	                        }
                        	                elsif ($perc_free < $orange_warn) {
                                	                $perc_string = "<td bgcolor=\"orange\">".$perc_free." %</td>";
                                        	}
						elsif ($perc_free < $yellow_warn) {
                                                        $perc_string = "<td bgcolor=\"yellow\">".$perc_free." %</td>";
                                                }
                                        	else {
                                                	$perc_string = "<td>".$perc_free." %</td>";
                                        	}
                                        }
                                        else {
                                                $perc_free = "UNKNOWN";
                                                $ds_used = "UNKNOWN";
                                                $ds_free = "UNKNOWN";
                                        }
					$ds_row = "</td><td>".(prettyPrintData($ds->summary->capacity,'B'))."</td><td>".$ds_used."</td><td>".prettyPrintData($ds->summary->freeSpace,'B')."</td>$perc_string<td>".$ds->summary->type."</td>";
					
					#get all hosts attached to this datastore
					my $host_mounts = $ds->host;
					foreach (@$host_mounts) {
						my $host_on_datastore = Vim::get_view (mo_ref => $_->key);
							if($_->mountInfo->accessible) {
							push @hosts_to_datastores,$host_on_datastore->summary->config->name;	
							}
					}

					#logic to figure out which hosts can not see this datastore
					my @intersection = ();
					my @difference = ();
					my %count = ();
					foreach my $element (@hosts_to_datastores, @hosts_seen) { $count{$element}++ }
    					foreach my $element (keys %count) {
        					push @{ $count{$element} > 1 ? \@intersection : \@difference }, $element;
    					}
	
					#only check if its shared storage	
					#if($ds->summary->multipleHostAccess) {	
						if(@difference) {
							my $hosts_not_accessible = "";
							foreach (@difference) {
								$hosts_not_accessible .= $_." "; 
							}
							if($enable_demo_mode eq 1) {
                                                		$ds_row .= "<td bgcolor=\"#FF6666\">HIDE ME!</td>";
                                        		} else {
								$ds_row .= "<td bgcolor=\"#FF6666\">$hosts_not_accessible</td>";
							}
						}
						else {
							$ds_row .= "<td bgcolor=\"#66FF99\">Accessible by all hosts in this cluster</td>";
						}
					#} else { $ds_row .= "<td>N/A</td>"; }
	
					$datastore_row_info{$ds->info->name} = $ds_row;
					@hosts_to_datastores = ();
                                }
                }
        }
	#final print of datastore summary
	for my $datastore ( sort keys %datastore_row_info ) {
		my $value = $datastore_row_info{$datastore};
		print REPORT_OUTPUT "<tr><td>",$datastore,"</td>",$value,"</tr>";
	}
        print REPORT_OUTPUT "</table>\n";
}

sub printHostLun {
	my ($local_hosts) = @_;
	my %lun_row_info = ();
	my %luns = ();
        foreach my $host (@$local_hosts) {
		my $luns = $host->config->storageDevice->scsiLun;
		foreach (sort {$a->canonicalName cmp $b->canonicalName} @$luns) {
			my $lun_row = "";
			if($_->isa('HostScsiDisk')) {
				$luns{$_->uuid} .= $host->summary->config->name . "_" . $_->canonicalName . "," ;
				$lun_row .= "<td>".$_->canonicalName."</td";
				if($_->queueDepth) { $lun_row .= "<td>".$_->queueDepth."</td"; }
                                else { $lun_row .= "<td>N/A</td"; }
				my $state_string = "";
				my $states = $_->operationalState;
				foreach (@$states) {
					$state_string .= $_." ";
				}
				
				$lun_row .= "<td>".$state_string."</td><td>".$_->vendor."</td>";
				$lun_row_info{$_->uuid} = $lun_row;
			}
		}
	}
	
	#logic to check which hosts can see all luns
	while ( my ($uuid, $value) = each(%luns) ) {
		my @pairs = split(',',$value);
    		my $pair_count = @pairs;
		my @hosts_to_luns = ();
    		for (my $x=0;$x < $pair_count;$x++) {
			(my $hostname,my $vmhba) = split('_',$pairs[$x],2);
			push @hosts_to_luns, $hostname;
		}
		#logic to figure out which hosts can not see this datastore
                my @intersection = ();
                my @difference = ();
                my %count = ();
                foreach my $element (@hosts_to_luns, @hosts_seen) { $count{$element}++ }
                foreach my $element (keys %count) {
                	push @{ $count{$element} > 1 ? \@intersection : \@difference }, $element;
                }

		my $print_string = "";
		if(@difference) {
			foreach (@difference) {
				$print_string .= $_." ";
			}
		}
		if($print_string eq '') {
			$print_string = "<td bgcolor=\"#66FF99\">Accessible by all hosts in this cluster</td>";
		} else {
			if($enable_demo_mode eq 1) {
                                $print_string .= "<td bgcolor=\"#FF6666\">HIDE ME!</td>";
                        }
			else {
				$print_string = "<td bgcolor=\"#FF6666\">".$print_string."</td>";
			}
		}
		$lun_row_info{$uuid} .= $print_string;
		@hosts_to_luns = ();
	}

	###########################
        # PRINT LUN SUMMARY
        ###########################
        push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#ESX/ESXi LUN(s)-$cluster_count\">ESX/ESXi LUN(s)</a><br>";
        print REPORT_OUTPUT "<a name=\"ESX/ESXi LUN(s)-$cluster_count\"></a>";
        print REPORT_OUTPUT "<H3>ESX/ESXi LUN(s):</H3>\n";
        print REPORT_OUTPUT "<table border=1>\n";
        print REPORT_OUTPUT "<tr><th>UUID</th><th>LUN</th><th>QUEUE DEPTH</th><th>STATUS</th><th>VENDOR</th><th>HOST(s) NOT ACCESSIBLE TO LUN</tr>";
	for my $lun ( sort keys %lun_row_info ) {
                my $value = $lun_row_info{$lun};
                print REPORT_OUTPUT "<tr><td>",$lun,"</td>",$value,"</tr>";
        }
	print REPORT_OUTPUT "</table>\n";
}

sub printHostPortgroup {
	my ($local_hosts) = @_;
	my @hosts_to_portgroups = ();
	my %portgroup_row_info = ();
	foreach my $host (@$local_hosts) {
                my $portgroup_views = Vim::get_views (mo_ref_array => $host->network);
                foreach my $portgroup (sort {$a->summary->name cmp $b->summary->name} @$portgroup_views) {
			my $pg_row = "";
			if($portgroup->summary->accessible) {
				my $host_mounts = $portgroup->host;
				foreach (@$host_mounts) {
					my $host_on_portgroup = Vim::get_view (mo_ref => $_);
					push @hosts_to_portgroups,$host_on_portgroup->summary->config->name;
				}
			
				#logic to figure out which hosts can not see this portgroup
				my @intersection = ();
                                my @difference = ();
                                my %count = ();
                                foreach my $element (@hosts_to_portgroups, @hosts_seen) { $count{$element}++ }
                                foreach my $element (keys %count) {
                                	push @{ $count{$element} > 1 ? \@intersection : \@difference }, $element;
                                }
				if(@difference) {
                                	my $hosts_not_accessible = "";
                                        foreach (@difference) {
                                        	$hosts_not_accessible .= $_." ";
                                        }
					if($enable_demo_mode eq 1) {
                                        	$pg_row .= "<td bgcolor=\"#FF6666\">HIDE ME!</td>";
					} else {
						$pg_row .= "<td bgcolor=\"#FF6666\">$hosts_not_accessible</td>";
					}
                                }
                                else {
                                	$pg_row .= "<td bgcolor=\"#66FF99\">Accessible by all hosts in this cluster</td>";
                                }
				$portgroup_row_info{$portgroup->name} = $pg_row;
				@hosts_to_portgroups = ();
			}
		}
	}

	#final print of portgroup summary
	###########################
        # PRINT PORTGROUP SUMMARY
        ###########################
        push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#ESX/ESXi Portroup(s)-$cluster_count\">ESX/ESXi Portroup(s)</a><br>";
        print REPORT_OUTPUT "<a name=\"ESX/ESXi Portroup(s)-$cluster_count\"></a>";
        print REPORT_OUTPUT "</table>\n";
        print REPORT_OUTPUT "<H3>ESX/ESXi Portroup(s):</H3>\n";
        print REPORT_OUTPUT "<table border=1>\n";
        print REPORT_OUTPUT "<tr><th>PORTGROUP</th><th>HOST(s) NOT ACCESSIBLE TO PORTGROUP</th></tr>";
        for my $portgroup ( sort keys %portgroup_row_info ) {
                my $value = $portgroup_row_info{$portgroup};
		if($enable_demo_mode eq 1) {
			$portgroup = "HIDE MY PG!";
		}
                print REPORT_OUTPUT "<tr><td>",$portgroup,"</td>",$value,"</tr>";
        }
        print REPORT_OUTPUT "</table>\n";
}

sub printHostHardwareInfo {
	my ($local_hosts) = @_;

	###########################
        # PRINT HOST HARDWARE
        ###########################
	push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#ESX/ESXi hardware configuration-$cluster_count\">ESX/ESXi hardware configuration</a><br>";
	print REPORT_OUTPUT "<a name=\"ESX/ESXi hardware configuration-$cluster_count\"></a>";
        print REPORT_OUTPUT "<table border=1>\n";
        print REPORT_OUTPUT "<tr><th>HOSTNAME</th><th>VENDOR</th><th>CPU INFO</th><th>HT AVAILABLE/ENABLED</th><th>CPU SPEED</th><th>CPU USAGE</th><th>CPU PACKAGE(s)</th><th>CPU CORE(s)</th><th>CPU THREAD(s)</th><th>MEMORY</th><th>MEMORY USAGE</th><th>NIC(s)</th><th>HBA(s)</th></tr>\n";
        print REPORT_OUTPUT "<H3>ESX/ESXi hardware configuration:</H3>\n";
        foreach my $local_host (sort {$a->summary->config->name cmp $b->summary->config->name} @$local_hosts) {
                print REPORT_OUTPUT "<tr>\n";
		if($enable_demo_mode eq 1) {
                	print REPORT_OUTPUT "<td>HIDE ME!</td>";
               	}
                else {
                	print REPORT_OUTPUT "<td>",$local_host->summary->config->name,"</td>";
		}
                print REPORT_OUTPUT "<td>",$local_host->summary->hardware->vendor,"</td>";
                print REPORT_OUTPUT "<td>",$local_host->summary->hardware->cpuModel,"</td>";
                print REPORT_OUTPUT "<td>",($local_host->config->hyperThread->available) ? "YES" : "NO"," / ";
		print REPORT_OUTPUT ($local_host->config->hyperThread->active) ? "YES" : "NO","</td>";
                print REPORT_OUTPUT "<td>",prettyPrintData($local_host->summary->hardware->numCpuCores*$local_host->summary->hardware->cpuMhz,'MHZ'),"</td>";
                print REPORT_OUTPUT "<td>",prettyPrintData($local_host->summary->quickStats->overallCpuUsage,'MHZ'),"</td>";
                print REPORT_OUTPUT "<td>",$local_host->summary->hardware->numCpuPkgs,"</td>";
                print REPORT_OUTPUT "<td>",$local_host->summary->hardware->numCpuCores,"</td>";
                print REPORT_OUTPUT "<td>",$local_host->summary->hardware->numCpuThreads,"</td>";
                print REPORT_OUTPUT "<td>",prettyPrintData($local_host->summary->hardware->memorySize,'B'),"</td>";
                print REPORT_OUTPUT "<td>",prettyPrintData($local_host->summary->quickStats->overallMemoryUsage,'M'),"</td>";
                print REPORT_OUTPUT "<td>",$local_host->summary->hardware->numNics,"</td>";
                print REPORT_OUTPUT "<td>",$local_host->summary->hardware->numHBAs,"</td>";
                print REPORT_OUTPUT "</tr>\n";

		#capture unique hosts for later use
	        push @hosts_seen,$local_host->summary->config->name;

	        #get vswitch/cdp info
                #getVswitchInfo($local_host);

                #get nic
		getNICInfo($local_host);

                #get hba
                getHBAInfo($local_host);

        }
	print REPORT_OUTPUT "</table>\n";

        #print nic
	###########################
        # PRINT NIC INFO
        ###########################
        printNIC();

        ###########################
        # PRINT HBA INFO
        ###########################
        printHBA();

	#print cdp
		

        ###########################
        # PRINT HOST STATE
        ###########################
        print REPORT_OUTPUT "</table>\n";
        print REPORT_OUTPUT "<H3>ESX/ESXi state:</H3>\n";
        print REPORT_OUTPUT "<table border=1>\n";
        print REPORT_OUTPUT "<tr><th>HOSTNAME</th><th>OVERALL STATUS</th><th>POWER STATE</th><th>CONNECTION STATE</th><th>MAINTENANCE MODE</th><th>VMOTION ENABLED</th><th>VERSION</th></tr>\n";
        foreach my $local_host (sort {$a->summary->config->name cmp $b->summary->config->name} @$local_hosts) {
                print REPORT_OUTPUT "<tr>\n";
		if($enable_demo_mode eq 1) {
                	print REPORT_OUTPUT "<td>HIDE ME!</td>";
                }
		else {
			print REPORT_OUTPUT "<td>",$local_host->summary->config->name,"</td>";
		}
                my $host_health = $local_host->overallStatus->val;
                if ($host_health eq 'green') { print REPORT_OUTPUT "<td bgcolor=\"green\">HOST is OK</td>"; }
                elsif ($host_health eq 'red') { print REPORT_OUTPUT "<td bgcolor=\"red\">HOST has a problem</td>"; }
                elsif ($host_health eq 'yellow') { print REPORT_OUTPUT "<td bgcolor=\"yellow\">HOST might have a problem</td>"; }
                else { print REPORT_OUTPUT "<td bgcolor=\"gray\">UNKNOWN</td>"; }
                print REPORT_OUTPUT "<td>",$local_host->runtime->powerState->val,"</td>";
                print REPORT_OUTPUT "<td>",$local_host->runtime->connectionState->val,"</td>";
                print REPORT_OUTPUT "<td>",($local_host->summary->runtime->inMaintenanceMode) ? "YES" : "NO" ,"</td>";
                print REPORT_OUTPUT "<td>",($local_host->summary->config->vmotionEnabled) ? "YES" : "NO" ,"</td>";
                print REPORT_OUTPUT "<td>",${$local_host->summary->config->product}{'fullName'},"</td>";
                print REPORT_OUTPUT "</tr>\n";
        }
        print REPORT_OUTPUT "</table>\n";

	###########################
        # PRINT HOST CONFIG
        ###########################
        print REPORT_OUTPUT "</table>\n";
	push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#ESX/ESXi Config (WIP)-$cluster_count\">ESX/ESXi Config (WIP)</a><br>";
        print REPORT_OUTPUT "<a name=\"ESX/ESXi Config (WIP)-$cluster_count\"></a>";
        print REPORT_OUTPUT "<H3>ESX/ESXi Config (WIP):</H3>\n";
        print REPORT_OUTPUT "<table border=1>\n";
        print REPORT_OUTPUT "<tr><th>HOSTNAME</th><th>SC MEMORY</th><th><table border=1 width=100%><tr><td><b>NTP SERVER(s)</b></td><td><b>TIME ZONE</b></td><td><b>GMT OFFSET</b></td><td><b>LOCATION</b></td></tr></table></th><th>AUTOSTART MANAGER</th><th>LVM.EnableResignature</th><th>LVM.DisallowSnapshotLun</th><th>Disk.UseDeviceReset</th><th>Disk.UseLunReset</th></tr>\n";
	foreach my $local_host (sort {$a->summary->config->name cmp $b->summary->config->name} @$local_hosts) {
                print REPORT_OUTPUT "<tr>\n";
		if($enable_demo_mode eq 1) {
                	print REPORT_OUTPUT "<td>HIDE ME!</td>";
                }
		else {        
                	print REPORT_OUTPUT "<td>",$local_host->summary->config->name,"</td>";
		}
		if(defined($local_host->config->consoleReservation)) {
			print REPORT_OUTPUT "<td>",prettyPrintData($local_host->config->consoleReservation->serviceConsoleReserved,'B'),"</td>";
		}
		else {
			print REPORT_OUTPUT "<td>UNKNOWN</td>";
		}
		my $ntps = $local_host->config->dateTimeInfo->ntpConfig->server;
		my $ntp_string = "";
		if($ntps) {
			print REPORT_OUTPUT "<td><table border=1 width=100%><tr>\n";
        		foreach (@$ntps) {
				$ntp_string .= "$_<br>";
        		}
			print REPORT_OUTPUT "<td>",$ntp_string,"</td>";
			print REPORT_OUTPUT "<td>",$local_host->config->dateTimeInfo->timeZone->description,"</td>";
			print REPORT_OUTPUT "<td>",$local_host->config->dateTimeInfo->timeZone->gmtOffset," Sec(s)</td>";
        		print REPORT_OUTPUT "<td>",$local_host->config->dateTimeInfo->timeZone->name,"</td>";
			print REPORT_OUTPUT "</tr></table></td>\n";
		}
		else {
			print REPORT_OUTPUT "<td>UNKNOWN</td>";
		}
        	print REPORT_OUTPUT "<td>",($local_host->config->autoStart->defaults->enabled) ? "YES" : "NO","</td>";

		#advconfigs
		my $advconfigs = Vim::get_view (mo_ref => $local_host->configManager->advancedOption);
		my $options_ref = $advconfigs->setting;
		foreach my $option (@$options_ref) {
			my $key = $option->key;
			my $value = $option->value;
			if($key eq 'LVM.EnableResignature') {
				print REPORT_OUTPUT "<td>",($value) ? "YES" : "NO","</td>";
			}
			if($key eq 'LVM.DisallowSnapshotLun') {
                                print REPORT_OUTPUT "<td>",($value) ? "YES" : "NO","</td>";
                        }
			if($key eq 'Disk.UseDeviceReset') {
				print REPORT_OUTPUT "<td>",($value) ? "YES" : "NO","</td>";
			}
			if($key eq 'Disk.UseLunReset') {
				print REPORT_OUTPUT "<td>",($value) ? "YES" : "NO","</td>";
			}
		}
=no
		if($local_host->config->activeDiagnosticPartition) {
			print $local_host->config->activeDiagnosticPartition->diagnosticType,"\n";
			print $local_host->config->activeDiagnosticPartition->id->diskName,print $local_host->config->activeDiagnosticPartition->id->partition,"\n";
			print $local_host->config->activeDiagnosticPartition->storageType,"\n\n";
		}
=cut
	}
	print REPORT_OUTPUT "</table>\n";
}

sub printHBA {
	if(@hba_list) {
		push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#ESX/ESXi HBA(s)-$cluster_count\">ESX/ESXi HBA(s)</a><br>";
        	print REPORT_OUTPUT "<a name=\"ESX/ESXi HBA(s)-$cluster_count\"></a>";
        	print REPORT_OUTPUT "<H3>ESX/ESXi HBA(s)</H3>\n";
        	print REPORT_OUTPUT "<table border=1>\n";
        	print REPORT_OUTPUT "<tr><th>HOST</th><th>HBA TYPE</th><th>DEVICE</th><th>PCI</th><th>MODEL</th><th>DRIVER</th><th>STATUS</th><th>ADDITIONAL INFO</th></tr>";
		foreach (@hba_list) {
			print REPORT_OUTPUT "<tr>",$_,"</tr>";
		}
		print REPORT_OUTPUT "</table>\n";
	}
	@hba_list = ();	
}

sub printNIC {
	if(@nic_list) {
                push @jump_tags,"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<a href=\"#ESX/ESXi NIC(s)-$cluster_count\">ESX/ESXi NIC(s)</a><br>";
                print REPORT_OUTPUT "<a name=\"ESX/ESXi NIC(s)-$cluster_count\"></a>";
                print REPORT_OUTPUT "<H3>ESX/ESXi NIC(s)</H3>\n";
                print REPORT_OUTPUT "<table border=1>\n";
                print REPORT_OUTPUT "<tr><th>HOST</th><th>DEVICE</th><th>PCI</th><th>DRIVER</th><th>DUPLEX</th><th>SPEED</th><th>WOL ENABLED</th><th>MAC</th></tr>";
                foreach (@nic_list) {
                        print REPORT_OUTPUT "<tr>",$_,"</tr>";
                }
                print REPORT_OUTPUT "</table>\n";
        }
        @nic_list = ();
}

sub getNICInfo {
	my ($host) = @_;
	my $nics = $host->config->network->pnic;
	foreach my $nic (@$nics) {
		my $nic_string = "";
		if($enable_demo_mode eq 1) {
                        $nic_string = "<td>HIDE ME!</td>";
                }
                else {
                        $nic_string = "<td>".$host->name."</td>";
                }
		$nic_string .= "<td>".$nic->device."</td><td>".$nic->pci."</td><td>".$nic->driver."</td>";
		if($nic->linkSpeed) {
			$nic_string .= "<td>".(($nic->linkSpeed->duplex) ? "FULL DUPEX" : "HALF-DUPLEX")."</td><td>".$nic->linkSpeed->speedMb." MB</td>";
		}
		else {
			$nic_string .= "<td>UNKNOWN</td><td>UNKNOWN</td>";
		}
		$nic_string .= "<td>".(($nic->wakeOnLanSupported) ? "YES" : "NO")."</td>";
		if($enable_demo_mode eq 1) {
                        $nic_string .= "<td>XX:XX:XX:XX:XX:XX</td>";
		}	
		else {
			$nic_string .= "<td>".$nic->mac."</td>";
		}
		push @nic_list,$nic_string;
	}
}

sub getHBAInfo {
	my ($host) = @_;
	my $hbas = $host->config->storageDevice->hostBusAdapter;
	foreach my $hba (@$hbas) {
		my $hba_string = "";
		if($enable_demo_mode eq 1) {
                        $hba_string = "<td>HIDE ME!</td>";
                }
                else {
                	$hba_string = "<td>".$host->name."</td>";
                }
        	if ($hba->isa("HostFibreChannelHba")) {
			my $nwwn = (Math::BigInt->new($hba->nodeWorldWideName))->as_hex();
			my $pwwn = (Math::BigInt->new($hba->portWorldWideName))->as_hex();
                        $nwwn =~ s/^..//;
			$pwwn =~ s/^..//;
                        $nwwn = join(':', unpack('A2' x 8, $nwwn));
			$pwwn = join(':', unpack('A2' x 8, $pwwn));
			if($enable_demo_mode eq 1) {
                        	$nwwn = "XX:XX:XX:XX:XX:XX:XX:XX";
                                $pwwn = "XX:XX:XX:XX:XX:XX:XX:XX";
			}
			$hba_string .= "<td>FC</td><td>".$hba->device."</td><td>".$hba->pci."</td><td>".$hba->model."</td><td>".$hba->driver."</td><td>".$hba->status."</td><td><b>NWWN</b> ".$nwwn."</td><td><b>PWWN</b> ".$pwwn."</td><td><b>PORT TYPE</b> ".$hba->portType->val."</td></td>";
                } elsif ($hba->isa("HostInternetScsiHba")) {
                        $hba_string .= "<td>iSCSI</td><td>".$hba->device."</td><td>".$hba->pci."</td><td>".$hba->model."</td><td>".$hba->driver."</td><td>".$hba->status."</td><td>".(($hba->authenticationProperties->chapAuthEnabled) ? "CHAP ENABLED" : "CHAP DISABLED")."</td>";
                }
		elsif ($hba->isa("HostParallelScsiHba")) {
			$hba_string .= "<td>SCSI</td><td>".$hba->device."</td><td>".$hba->pci."</td><td>".$hba->model."</td><td>".$hba->driver."</td><td>".$hba->status."</td><td>";
		}
		elsif ($hba->isa("HostBlockHba")) {
			$hba_string .= "<td>BLOCK</td><td>".$hba->device."</td><td>".$hba->pci."</td><td>".$hba->model."</td><td>".$hba->driver."</td><td>".$hba->status."</td><td>";
		}
		push @hba_list,$hba_string;
	}
}

sub getVswitchInfo {
                my $netMgr = Vim::get_view(mo_ref => $_->configManager->networkSystem);
                my @physicalNicHintInfo = $netMgr->QueryNetworkHint();
                foreach (@physicalNicHintInfo){
                        foreach ( @{$_} ){
                                if(defined($_->connectedSwitchPort)) {
                                        my $device = $_->device;
                                        my $port = $_->connectedSwitchPort->portId;
                                        $cdp_enabled{$device} = $port;
                                }
                        }
                }

                my $vswitches = $_->config->network->vswitch;
                foreach my $vSwitch (@$vswitches) {
                        my $pNicName = "";
                        my $mtu = "";
                        my $cdp_vswitch = "";

                        print "Switch Name     Num Ports       Used Ports      MTU     Uplinks          CDP Enabled\n";
                        my $pNics = $vSwitch->pnic;
                        my $pNicKey = "";
                        foreach (@$pNics) {
                                $pNicKey = $_;
                                if ($pNicKey ne "") {
                                        $pNics = $netMgr->networkInfo->pnic;
                                        foreach my $pNic (@$pNics) {
                                                if ($pNic->key eq $pNicKey) {
                                                        $pNicName = $pNicName ? ("$pNicName," . $pNic->device) : $pNic->device;
                                                        if($cdp_enabled{$pNic->device}) {
                                                                $cdp_vswitch = $cdp_enabled{$pNic->device};
                                                        }
                                                        else {
                                                                $cdp_vswitch = "";
                                                        }
                                                }
                                        }
                                }
                        }
                        $mtu = $vSwitch->{mtu} if defined($vSwitch->{mtu});
                        printf("%-16.14s%-16s%-16s%-8s%-16s%-16s\n\n", $vSwitch->name,
                        $vSwitch->numPorts,
                        $vSwitch->numPorts - $vSwitch->numPortsAvailable,
                        $vSwitch->{mtu},
                        $pNicName,
                        $cdp_vswitch);
                        my $portGroups = $vSwitch->portgroup;
                        print "  PortGroup Name        VLAN ID   Used Ports      Uplinks\n";
                        foreach my $port (@$portGroups) {
                                my $pg = FindPortGroupbyKey ($netMgr, $vSwitch->key, $port);
                                next unless (defined $pg);
                                my $usedPorts = (defined $pg->port) ? $#{$pg->port} + 1 : 0;
                                printf("  %-22s%-10s%-16s%-16s\n", $pg->spec->name,
                                        $pg->spec->vlanId, $usedPorts, $pNicName);
                        }
                        print "\n";
                }
}

sub FindPortGroupbyKey {
   my ($network, $vSwitch, $key) = @_;
   my $portGroups = $network->networkInfo->portgroup;
   foreach my $pg (@$portGroups) {
      return $pg if (($pg->vswitch eq $vSwitch) && ($key eq $pg->key));
   }
   return undef;
}

sub printClusterSummary {
	my ($local_cluster) = @_;
        my $cluster_name = $local_cluster->name;
        my $cluster_host_cnt = $local_cluster->summary->numHosts;
        my $cluster_avail_host = $local_cluster->summary->numEffectiveHosts;
	my $cluster_cpu_cnt = prettyPrintData($local_cluster->summary->totalCpu,'MHZ');
	my $cluster_mem_cnt = prettyPrintData($local_cluster->summary->totalMemory,'B');
	my $cluster_avail_cpu = prettyPrintData($local_cluster->summary->effectiveCpu,'MHZ');
	my $cluster_avail_mem = prettyPrintData($local_cluster->summary->effectiveMemory,'M');
	my $cluster_drs = $local_cluster->configuration->drsConfig->enabled;
	my $cluster_ha = $local_cluster->configuration->dasConfig->enabled;
	my $cluster_dpm = $local_cluster->configurationEx->dpmConfigInfo->enabled;
	my $cpu_perc_string = "";
        my $mem_perc_string = "";

        print REPORT_OUTPUT "<br><hr>\n";

        ###########################
        # PRINT CLUSTER SUMMARY
        ###########################
	push @jump_tags,"CL<a href=\"#$cluster_name\">Cluster: $cluster_name</a><br>";
	print REPORT_OUTPUT "<a name=\"$cluster_name\"></a>";
        print REPORT_OUTPUT "<H2>Cluster: $cluster_name</H2>\n";
        print REPORT_OUTPUT "<H3>Cluster Statistics:</H3>\n";
	print REPORT_OUTPUT "<table border=1><tr><td bgcolor=\"#CCCCCC\"><b>COLOR LEGEND</b></td><td bgcolor=\"yellow\"><b>YELLOW < $yellow_warn %</b></td><td bgcolor=\"orange\"><b>ORANGE < $orange_warn %</b></td><td bgcolor=\"red\"><b>RED < $red_warn %</b></td></tr></table>";
        print REPORT_OUTPUT "<table border=1>\n";
        print REPORT_OUTPUT "<tr><th>AVAILABLE HOST(s)</th><th>AVAILABLE CPU</th><th>CPU % FREE</th><th>AVAILABLE MEM</th><th>MEM % FREE</th><th>DRS ENABLED</th><th>HA ENABLED</th><th>DPM ENABLED</th></tr>\n";
        print REPORT_OUTPUT "<tr>";
        print REPORT_OUTPUT "<td>",$cluster_avail_host,"/",$cluster_host_cnt,"</td>";
        print REPORT_OUTPUT "<td>",$cluster_avail_cpu,"/",$cluster_cpu_cnt,"</td>";

	if(($local_cluster->summary->effectiveCpu > 0) && ($local_cluster->summary->totalCpu > 0)) {
		my $cpu_perc_free = &restrict_num_decimal_digits( ((100 * ($local_cluster->summary->effectiveCpu*0.001))/($local_cluster->summary->totalCpu*0.001)),2);
		if($cpu_perc_free < $red_warn) { $cpu_perc_string = "<td bgcolor=\"red\">".$cpu_perc_free." %</td>"; }
        	elsif ($cpu_perc_free < $orange_warn) { $cpu_perc_string = "<td bgcolor=\"orange\">".$cpu_perc_free." %</td>"; }
        	elsif ($cpu_perc_free < $yellow_warn) { $cpu_perc_string = "<td bgcolor=\"yellow\">".$cpu_perc_free." %</td>"; }
        	else { $cpu_perc_string = "<td>".$cpu_perc_free." %</td>"; }
	}
	else {
		$cpu_perc_string = "<td>0</td>";
	}
	print REPORT_OUTPUT $cpu_perc_string;
        print REPORT_OUTPUT "<td>",$cluster_avail_mem,"/",$cluster_mem_cnt,"</td>";

	if(($local_cluster->summary->effectiveMemory > 0) && ($local_cluster->summary->totalMemory > 0)) {	
		my $mem_perc_free = &restrict_num_decimal_digits( ((100 * ($local_cluster->summary->effectiveMemory/1024))/($local_cluster->summary->totalMemory/1024/1024/1000)),2);
		if($mem_perc_free < $red_warn) { $mem_perc_string = "<td bgcolor=\"red\">".$mem_perc_free." %</td>"; }
        	elsif ($mem_perc_free < $orange_warn) { $mem_perc_string = "<td bgcolor=\"orange\">".$mem_perc_free." %</td>"; }
        	elsif ($mem_perc_free < $yellow_warn) { $mem_perc_string = "<td bgcolor=\"yellow\">".$mem_perc_free." %</td>"; }
        	else { $mem_perc_string = "<td>".$mem_perc_free." %</td>"; }
	}
	else {
		$mem_perc_string = "<td>0</td>";
	}
	
        print REPORT_OUTPUT $mem_perc_string;
	print REPORT_OUTPUT "<td>",($cluster_drs) ? "YES" : "NO","</td>";
	print REPORT_OUTPUT "<td>",($cluster_ha) ? "YES" : "NO" ,"</td>";
	print REPORT_OUTPUT "<td>",($cluster_dpm) ? "YES" : "NO" ,"</td>";
	print REPORT_OUTPUT "</table>\n";

        ###########################
        # PRINT HA INFO
        ###########################
        if($cluster_ha) {
                print REPORT_OUTPUT "<H3>HA CONFIGURATIONS:</H3>\n";
                print REPORT_OUTPUT "<table border=1>\n";
                print REPORT_OUTPUT "<tr><th>FAILOVER LEVEL</th><th>ADMISSION CONTROLED ENABLED</th><th>ISOLATION RESPONSE</th><th>RESTART PRIORITY</th></tr>\n";
                print REPORT_OUTPUT "<td>",$local_cluster->configuration->dasConfig->failoverLevel,"</td>";
                print REPORT_OUTPUT "<td>",($local_cluster->configuration->dasConfig->admissionControlEnabled) ? "YES" : "NO","</td>";
                print REPORT_OUTPUT "<td>",$local_cluster->configuration->dasConfig->defaultVmSettings->isolationResponse,"</td>";
                print REPORT_OUTPUT "<td>",$local_cluster->configuration->dasConfig->defaultVmSettings->restartPriority,"</td>";
                print REPORT_OUTPUT "</table>\n";
        }

	###########################
        # PRINT DRS INFO 
        ###########################
	if($cluster_drs) {
        	print REPORT_OUTPUT "<H3>DRS CONFIGURATIONS:</H3>\n";
        	print REPORT_OUTPUT "<table border=1>\n";
        	print REPORT_OUTPUT "<tr><th>DRS BEHAVIOR</th><th>VMOTION RATE</th></tr>\n";
		print REPORT_OUTPUT "<td>",$local_cluster->configuration->drsConfig->defaultVmBehavior->val,"</td>";
		print REPORT_OUTPUT "<td>",$local_cluster->configuration->drsConfig->vmotionRate,"</td>";
		print REPORT_OUTPUT "</table>\n";
	}

	###########################
        # PRINT DPM INFO
        ###########################
        if($cluster_dpm) {
		print REPORT_OUTPUT "<H3>DRS CONFIGURATIONS:</H3>\n";
                print REPORT_OUTPUT "<table border=1>\n";
                print REPORT_OUTPUT "<tr><th>DPM BEHAVIOR</th></tr>\n";
		print REPORT_OUTPUT "<td>",$local_cluster->configurationEx->dpmConfigInfo->defaultDpmBehavior->val,"</td>";
		print REPORT_OUTPUT "</table>\n";
	}

        ###########################
        # PRINT CLUSTER RULES
        ###########################
        my $rules = $local_cluster->configurationEx->rule;
        if($rules) {
                print REPORT_OUTPUT "<H3>Cluster Rules:</H3>\n";
                print REPORT_OUTPUT "<table border=1>\n";
                print REPORT_OUTPUT "<tr><th>RULE NAME</th><th>RULE TYPE</th><th>ENABLED</th></tr>\n";
                foreach (@$rules) {
                        my $rule = $_;
                        my $is_enabled = $rule->enabled;
                        my $rule_name = $rule->name;
			my $rule_type;
			if(ref($rule) eq 'ClusterAffinityRuleSpec') {
				$rule_type = "AFFINITY";
			}
			elsif (ref($rule) eq 'ClusterAntiAffinityRuleSpec') {
				$rule_type = "ANTI-AFFINITY";
			}
                        print REPORT_OUTPUT "</tr><td>",$rule_name,"</td><td>",$rule_type,"</td><td>",($is_enabled) ? "YES" : "NO","</td></tr>";
                }
                print REPORT_OUTPUT "</table>\n";
        }
}

sub printBuildSummary {
	# get ServiceContent
	my $content = Vim::get_service_content();
	my $print_type;
	if ($content->about->apiType eq 'VirtualCenter') {	
		$print_type = "VMware vCenter";
	}
	else {
		$print_type = "VMware ESX/ESXi";
	}

	print REPORT_OUTPUT "<H2>$print_type:</H2>\n";
        print REPORT_OUTPUT "<table border=1>\n";
        print REPORT_OUTPUT "<tr><th>BUILD</th><th>VERSION</th><th>FULL NAME</th>\n";
	print REPORT_OUTPUT "<tr>";
	print REPORT_OUTPUT "<td>",$content->about->build,"</td><td>",$content->about->version,"</td><td>",$content->about->fullName,"</td>\n";
	print REPORT_OUTPUT "</tr>";
	print REPORT_OUTPUT "</table><br>\n";
	#please do not touch this, else the jump tags will break
	print REPORT_OUTPUT "\n/<!-- insert here -->/\n";
}

sub printStartHeader {
	print "Generating VMware Health Report \"$report_name\" (this can take a few minutes depending on environment size. Get a cup of coffee/tea and come back) ...\n";
	
	### begin_: initialize DateTime values
	my %dttime = ();
	my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);

	### begin_: initialize DateTime number formats
	$dttime{year }  = sprintf "%04d",($year + 1900);  ## four digits to specify the year
	$dttime{mon  }  = sprintf "%02d",($mon + 1);      ## zeropad months
	$dttime{mday }  = sprintf "%02d",$mday;           ## zeropad day of the month
	$dttime{wday }  = sprintf "%02d",$wday + 1;       ## zeropad day of week; sunday = 1;
	$dttime{yday }  = sprintf "%02d",$yday;           ## zeropad nth day of the year
	$dttime{hour }  = sprintf "%02d",$hour;           ## zeropad hour
	$dttime{min  }  = sprintf "%02d",$min;            ## zeropad minutes
	$dttime{sec  }  = sprintf "%02d",$sec;            ## zeropad seconds
	$dttime{isdst}  = $isdst;

	$my_time = "Date: $dttime{mon}-$dttime{mday}-$dttime{year} $dttime{hour}:$dttime{min}:$dttime{sec}";

	$start_time = time();
	open(REPORT_OUTPUT, ">$report_name");
	print REPORT_OUTPUT "<html>\n";
	print REPORT_OUTPUT "<title>VMware Health Check Report $version - $my_time</title>\n";
	print REPORT_OUTPUT "<META NAME=\"AUTHOR\" CONTENT=\"William Lam\">\n";
	print REPORT_OUTPUT "<style type=\"text/css\">\n";
	print REPORT_OUTPUT "body { background-color:#EEEEEE; }\n";
	print REPORT_OUTPUT "body,table,td,th { font-family:Tahoma; color:Black; Font-Size:10pt }\n";
	print REPORT_OUTPUT "th { font-weight:bold; background-color:#CCCCCC; }\n";
	print REPORT_OUTPUT "a:link { color: blue; }\n";
	print REPORT_OUTPUT "a:visited { color: blue; }\n";
	print REPORT_OUTPUT "a:hover { color: blue; }\n";
	print REPORT_OUTPUT "a:active { color: blue; }\n";

	print REPORT_OUTPUT "</style>\n";

	print REPORT_OUTPUT "<H1>VMware Health Check Report $version</H1>\n";
	print REPORT_OUTPUT "$my_time\n";
}

sub printCloseHeader {
	print REPORT_OUTPUT "<br><hr>\n";
	print REPORT_OUTPUT "<center>Author: <b><a href=\"http://engineering.ucsb.edu/~duonglt/vmware/\">William Lam</a></b></center>";
	print REPORT_OUTPUT "<center>Generated using: <b><a href=\"http://communities.vmware.com/docs/DOC-9420\">vmwareHealthCheck.pl</a></b></center>";
	print REPORT_OUTPUT "<center>&#0153;Primp Industries</center>";
	close(REPORT_OUTPUT);

	my @lines;
	my $jump_string = "";
	tie @lines, 'Tie::File', $report_name or die;
	for (@lines) {
        	if (/<!-- insert here -->/) {
                	foreach (@jump_tags) {
                        	if( ($_ =~ /^CL/) ) {
                                	my $tmp_string = substr($_,2);
                                	$jump_string .= $tmp_string;
                        	}
                        	else {
                                	$jump_string .= $_;
                        	}
                	}
                	$_ = "\n$jump_string";
                	last;
        	}
	}
	untie @lines;

	$end_time = time();
	$run_time = $end_time - $start_time;
	print "\nStart Time: ",&formatTime(str => scalar localtime($start_time)),"\n";
	print "End   Time: ",&formatTime(str => scalar localtime($end_time)),"\n";

	if ($run_time < 60) {
        	print "Duration  : ",$run_time," Seconds\n\n";
	}
	else {
		print "Duration  : ",&restrict_num_decimal_digits($run_time/60,2)," Minutes\n\n";
	}
}

sub cleanUp {
	@hosts_seen = ();
}

sub Fail {
    my ($msg) = @_;
    Util::disconnect();
    die ($msg);
    exit ();
}

#http://www.bryantmcgill.com/Shazam_Perl_Module/Subroutines/utils_convert_bytes_to_optimal_unit.html
sub prettyPrintData{
	my($bytes,$type) = @_;

  	return '' if ($bytes eq '' || $type eq '');
	return 0 if ($bytes <= 0);

  	my($size);

	if($type eq 'B') {
  		$size = $bytes . ' Bytes' if ($bytes < 1024);
  		$size = sprintf("%.2f", ($bytes/1024)) . ' KB' if ($bytes >= 1024 && $bytes < 1048576);
  		$size = sprintf("%.2f", ($bytes/1048576)) . ' MB' if ($bytes >= 1048576 && $bytes < 1073741824);
  		$size = sprintf("%.2f", ($bytes/1073741824)) . ' GB' if ($bytes >= 1073741824 && $bytes < 1099511627776);
  		$size = sprintf("%.2f", ($bytes/1099511627776)) . ' TB' if ($bytes >= 1099511627776);
	}
	elsif($type eq 'M') {
		$bytes = $bytes * (1048576);
		$size = sprintf("%.2f", ($bytes/1048576)) . ' MB' if ($bytes >= 1048576 && $bytes < 1073741824);
                $size = sprintf("%.2f", ($bytes/1073741824)) . ' GB' if ($bytes >= 1073741824 && $bytes < 1099511627776);
                $size = sprintf("%.2f", ($bytes/1099511627776)) . ' TB' if ($bytes >= 1099511627776);
	}

	elsif($type eq 'G') {
		$bytes = $bytes * (1073741824);
		$size = sprintf("%.2f", ($bytes/1073741824)) . ' GB' if ($bytes >= 1073741824 && $bytes < 1099511627776);
                $size = sprintf("%.2f", ($bytes/1099511627776)) . ' TB' if ($bytes >= 1099511627776);
	}
	elsif($type eq 'MHZ') {
		$size = sprintf("%.2f", ($bytes/1e-06)) . ' Mhz' if ($bytes >= 1e-06 && $bytes < 0.001);
		$size = sprintf("%.2f", ($bytes*0.001)) . ' Ghz' if ($bytes >= 0.001);
	}

  	return $size;
}

# restrict the number of digits after the decimal point
#http://guymal.com/mycode/perl_restrict_digits.shtml
sub restrict_num_decimal_digits {
	my $num=shift;#the number to work on
  	my $digs_to_cut=shift;# the number of digits after

  	if ($num=~/\d+\.(\d){$digs_to_cut,}/) {
    		$num=sprintf("%.".($digs_to_cut-1)."f", $num);
  	}
  	return $num;
}

#http://www.infocopter.com/perl/format-time.html
sub formatTime(%) {
        my %args = @_;
        $args{'str'} ||= ''; # e.g. Mon Jul 3 12:59:28 2006

        my @elems = ();
        foreach (split / /, $args{'str'}) {
                next unless $_;
                push(@elems, $_);
        }

        my ($weekday, $month, $mday, $time, $yyyy) = split / /, join(' ', @elems);

        my %months = (  Jan => 1, Feb => 2, Mar => 3, Apr =>  4, May =>  5, Jun =>  6,
                        Jul => 7, Aug => 8, Sep => 9, Oct => 10, Nov => 11, Dec => 12 );

        my $s  = substr($time, 6,2);
        my $m  = substr($time, 3,2);
        my $h  = substr($time, 0, 2);
        my $dd = sprintf('%02d', $mday);

        my $mm_num = sprintf('%02d', $months{$month});

        my $formatted = "$mm_num\-$dd\-$yyyy $h:$m:$s";
        #my $formatted = "$yyyy$mm_num$dd$h$m$s";

        $formatted;
}

sub print_tree {
        my ($vm, $ref, $tree) = @_;
        my $head = " ";
        foreach my $node (@$tree) {
                $head = ($ref->value eq $node->snapshot->value) ? " " : " " if (defined $ref);
                my $quiesced = ($node->quiesced) ? "YES" : "NO";
                my $desc = $node->description;
                if($desc eq "" ) { $desc = "NO DESCRIPTION"; }
                push @snapshot_vms,"<td>".$vm."</td><td>".$node->name."</td><td>".$desc."</td><td>".$node->createTime."</td><td>".$node->state->val."</td><td>".$quiesced."</td>";
                print_tree ($vm, $ref, $node->childSnapshotList);
        }
        return;
}


=head1 NAME

vmwareHealthCheck.pl - Generate VMware health check against vCenter Cluster(s). 

=head1 SYNOPSIS

vmwareHealthCheck.pl [--cluster "CLUSTER_NAME"]

=head1 DESCRIPTION

This script will generate a health check html report on each of the vCenter Cluster(s) for all residing ESX/ESXi hosts.

=head1 OPTIONS

=head1 EXAMPLES

List all of the connected cdrom devices on host abc.

      vmwareHealthCheck.pl --server "vCENTER_SERVER" --username "vCenter_USERNAME" --password "vCENTER_PASSWORD" 

=head1 SUPPORTED PLATFORMS

All operations are supported on ESX 3.5 and VirtualCenter 2.5 and better.