File: //var/opt/OV/bin/instrumentation/OvScope.pm
###############################
#
# @(#)HP Operations Smart Plug-ins for Infrastructure 11.14.014 06/07/14
#
###############################
package OvScope;
my $catalog = OvCommon::GetCatalog(qw/VmPerl/);
use OvVirtual;
use DiscoverResult;
use Data::Dumper;
use File::Path;
sub cleanupdisplayname {
my $vmname = shift;
if ($vmname =~ /&/) {
$vmname =~ s/&/-/g;
}
return $vmname;
}
sub new
{
my $class = shift;
my $self = {};
$self->{TYPE} = "";
$self->{VERSION} = "";
$self->{HOSTNAME} = "";
$self->{ROLE} = "";
$self->{MACHINEMODEL} = "";
$self->{VENDOR} = "";
$self->{PRODUCT} = "";
$self->{PROXYPRODUCT} = "";
$self->{HOSTLIST} = ();
$self->{FRAMELIST} = "";
$self->{GUESTLIST} = ();
$self->{RESPOOLLIST} = ();
$self->{HOSTTYPE} = ();
$self->{GUESTTYPE} = ();
$self->{SYSTEMNAME} = ();
$self->{HYPERVISORTYPE} = ();
$self->{CLUSTERUUIDLIST} = (); #hash to track UUIDs for clusters
$self->{RPUUIDMAPS} = (); # maps PAs UUID to correct UUID for RPs
$self->{SOURCE} = ();
$self->{DR} = DiscoverResult->new;
$self->{DATASTORELIST} = ();
$self->{VIRTUALAPPLIST} = ();
$self->{WPARLIST} = ();
bless ($self, $class);
return $self;
}
sub getESXHostList
{
my $self = shift;
my %hostlist = ();
open VIFPLIST, "vifp listservers|" or return 0;
while (<VIFPLIST>) {
if ( /esx|vcenter/i )
{
my ($hostname, $type) = split (/\s+/);
if (!exists ($hostlist{$type})) {
$hostlist{$type} = ();
}
push @{$hostlist{$type}},$hostname;
}
}
close (VIFPLIST);
return %hostlist;
}
sub vifpServerList
{
my $self = shift;
my @hostlist = ();
open VIFPLIST, "vifp listservers|" or return 0;
while (<VIFPLIST>)
{
if ( /esx|vcenter/i )
{
my ($hostname, $type) = split (/\s+/);
push @hostlist, $hostname, $type;
}
}
close (VIFPLIST);
return @hostlist;
}
sub getDataCenter
{
my $self = shift;
my $hostname = shift;
my $dcname;
my %vifplist = $self->getESXHostList();
my @vclist = $vifplist{'vCenter'};
return "ha-datacenter" if (!scalar(@vclist));
foreach my $vc (@vclist) {
$dcname = `/usr/bin/perl /var/opt/OV/bin/instrumentation/getdc.pl --hostname=$hostname --vcname=$vc->[0]`;
chomp ($dcname);
if ($dcname ne "") { return $dcname; }
}
return "ha-datacenter";
}
sub getVIInfo
{
my $self = shift;
my @hostArray, @guestArray, @respoolArray,@datastoreArray,@virtualapparray;
# Get configuration information (GBL metrics) from Host m/c
if ( $self->getConfigDetails() ne 0 )
{
return -1;
}
{
# Set === as record separator
local $/ = "===";
my $HPVM_HostDefined=0, $LPAR_FrameDefined=0, $KVM_HostDefined=0, $XEN_HostDefined=0;
open (OVCODADUMP, "ovcodautil -ds SCOPE -o LOGICAL -m BYLS_LS_NAME,BYLS_LS_UUID,BYLS_LS_ROLE,BYLS_LS_OSTYPE,BYLS_LS_PARENT_UUID,BYLS_LS_HOST_HOSTNAME,BYLS_LS_HOSTNAME,BYLS_MACHINE_MODEL,BYLS_DISPLAY_NAME,BYLS_IP_ADDRESS,BYLS_VC_IP_ADDRESS,BYLS_DATACENTER_NAME,BYLS_CLUSTER_NAME,BYLS_LS_STATE,BYLS_LS_TYPE,BYLS_LS_PARENT_TYPE,BYLS_MGMT_IP_ADDRESS -flat -last|") or return -1;
while (<OVCODADUMP>)
{
chomp;
my %cur_hash = {};
my @lines = split (/\n/, $_);
my $LsRole=undef;
if($_ =~ /DATASTORE/)
{
$LsRole = "DATASTORE";
}
foreach my $line (@lines)
{
chomp;
my @fields = ();
@fields = split (/\s*\:\s*/, $line);
if ((($self->{ROLE} eq "vMA") && ($self->{VENDOR} eq "VMware") && ($fields[0] eq "BYLS_LS_NAME")) || (($self->{ROLE} eq "HP Operations Agent") && ($self->{VENDOR} eq "VMware") && ($LsRole eq "DATASTORE") && (($fields[0] eq "BYLS_LS_NAME" )||($fields[0] eq "BYLS_DISPLAY_NAME" )) ))
{
my ($LsName,@UUidFeilds) = @fields;
my $UUID = join(":",@UUidFeilds);
$cur_hash{$fields[0]} = (($UUID)? $UUID: "na");
}
else
{
$cur_hash{$fields[0]} = (($fields[1])? $fields[1]: "na");
}
}
# check if the hash contains BYLS metrics and push the entire contents into appropriate array
if ( exists($cur_hash{"BYLS_LS_NAME"}) or exists($cur_hash{"BYLS_LS_UUID"}) )
{
my $role = $cur_hash{"BYLS_LS_ROLE"};
if ( $role eq undef )
{
$_ = $self->{PRODUCT};
SWITCH:
{
/hyper-v/i && do {
if ( $cur_hash{"BYLS_LS_NAME"} eq "Root" )
{
$role = "host";
# BYLS_LS_UUID=na for Root, replace that with proper value.
$cur_hash{"BYLS_LS_UUID"} = "Host".$self->{HOSTNAME};
$cur_hash{"BYLS_LS_OSTYPE"} = "Hyper-V Server";
$cur_hash{"BYLS_LS_HOSTNAME"} = OvCommon::getFQDN($cur_hash{"BYLS_LS_HOSTNAME"});
}
else
{
$role = "guest";
$cur_hash{"BYLS_LS_PARENT_UUID"} = "Host".$self->{HOSTNAME};
$cur_hash{"BYLS_LS_HOST_HOSTNAME"} = $self->{HOSTNAME};
}
last SWITCH;
};
/hpvm/i && do {
$role = "guest";
$cur_hash{"BYLS_LS_PARENT_UUID"} = "Host".$self->{HOSTNAME};
$cur_hash{"BYLS_LS_HOST_HOSTNAME"} = $self->{HOSTNAME};
# Since there's no host instance for HPVM, push Host details here only
if ( !$HPVM_HostDefined )
{
$HPVM_HostDefined=1;
my %curhost_hash = {};
$curhost_hash{"BYLS_LS_UUID"} = "Host".$self->{HOSTNAME};
$curhost_hash{"BYLS_LS_HOSTNAME"} = $self->{HOSTNAME};
$curhost_hash{"BYLS_LS_OSTYPE"} = "HPVM Host";
$curhost_hash{"BYLS_MACHINE_MODEL"} = $self->{MACHINEMODEL};
push ( @hostArray, \%curhost_hash);
}
last SWITCH;
};
/solaris containers/i && do {
if ( $cur_hash{"BYLS_LS_NAME"} eq "global" )
{
$role = "host";
# BYLS_LS_UUID=na for Root, replace that with proper value.
$cur_hash{"BYLS_LS_UUID"} = "Host".$self->{HOSTNAME};
if ( $cur_hash{"BYLS_LS_HOSTNAME"} eq "" )
{
$cur_hash{"BYLS_LS_HOSTNAME"} = $self->{HOSTNAME};
}
else
{
$self->{HOSTNAME} = $cur_hash{"BYLS_LS_HOSTNAME"};
}
$cur_hash{"BYLS_LS_OSTYPE"} = "Global Zone";
$cur_hash{"BYLS_MACHINE_MODEL"} = $self->{MACHINEMODEL};
}
else
{
$role = "guest";
my ($name, $version, $type) = split / /, $self->{VERSION};
$cur_hash{"BYLS_LS_OSTYPE"} = "SunOS".$version;
$cur_hash{"BYLS_LS_PARENT_UUID"} = "Host".$self->{HOSTNAME};
$cur_hash{"BYLS_LS_HOST_HOSTNAME"} = $self->{HOSTNAME};
}
last SWITCH;
};
};
}
#special for KVM
elsif ( lc($self->{PRODUCT}) eq "kvm" && !$KVM_HostDefined )
{
$cur_hash{"BYLS_LS_PARENT_UUID"} = "Host".$self->{HOSTNAME};
$KVM_HostDefined=1;
my %curhost_hash = {};
$curhost_hash{"BYLS_LS_UUID"} = "Host".$cur_hash{"BYLS_LS_HOST_HOSTNAME"};
$curhost_hash{"BYLS_LS_HOSTNAME"} = $cur_hash{"BYLS_LS_HOST_HOSTNAME"};
$curhost_hash{"BYLS_LS_OSTYPE"} = "KVM Host";
$curhost_hash{"BYLS_MACHINE_MODEL"} = $self->{MACHINEMODEL};
push ( @hostArray, \%curhost_hash);
}
#special for XEN
elsif ( lc($self->{PRODUCT}) eq "xen" )
{
$role = "guest";
$cur_hash{"BYLS_LS_PARENT_UUID"} = "Host".$self->{HOSTNAME};
$cur_hash{"BYLS_LS_HOST_HOSTNAME"} = $self->{HOSTNAME};
if ( !$XEN_HostDefined )
{
$XEN_HostDefined=1;
my %curhost_hash = {};
$curhost_hash{"BYLS_LS_UUID"} = "Host".$cur_hash{"BYLS_LS_HOST_HOSTNAME"};
$curhost_hash{"BYLS_LS_HOSTNAME"} = $cur_hash{"BYLS_LS_HOST_HOSTNAME"};
$curhost_hash{"BYLS_LS_OSTYPE"} = "XEN Host";
$curhost_hash{"BYLS_MACHINE_MODEL"} = $self->{MACHINEMODEL};
push ( @hostArray, \%curhost_hash);
}
}
#special for LPAR on latest Agent
elsif ( lc($self->{PRODUCT}) eq "lpar" )
{
if (lc($cur_hash{"BYLS_LS_ROLE"}) eq "guest")
{
$role = "guest";
}
elsif (lc($cur_hash{"BYLS_LS_ROLE"}) eq "host")
{
$role ="host";
}
my $partition_type = lc($cur_hash{"BYLS_LS_TYPE"});
if ( $partition_type eq "lpar" )
{
#$self->{HOSTNAME} = $cur_hash{"BYLS_LS_PARENT_UUID"};
$cur_hash{"BYLS_LS_HOST_HOSTNAME"} = "Frame ".$cur_hash{"BYLS_LS_PARENT_UUID"};
$partition_type = "lpar";
}
elsif ( $partition_type eq "sys wpar" )
{
#$self->{HOSTNAME} = $cur_hash{"BYLS_LS_PARENT_UUID"};
$cur_hash{"BYLS_LS_HOST_HOSTNAME"} = "Frame ".$cur_hash{"BYLS_LS_PARENT_UUID"};
$partition_type = "sys wpar";
}
elsif ( $partition_type eq "frame" )
{
$cur_hash{"BYLS_LS_HOST_HOSTNAME"} = "HMC ".$cur_hash{"BYLS_MGMT_IP_ADDRESS"};
$partition_type = "frame";
$self->{FRAMELIST} = $cur_hash{"BYLS_LS_HOSTNAME"};
}
else
{
#$self->{HOSTNAME} = split (/:/,$cur_hash{"BYLS_LS_PARENT_UUID"});
$cur_hash{"BYLS_LS_PARENT_UUID"} = "Frame_".split (/:/,$cur_hash{"BYLS_LS_PARENT_UUID"});
$partition_type = "(type unknown)";
}
$cur_hash{"BYLS_LS_OSTYPE"} = "IBM";
$cur_hash{"BYLS_DISPLAY_NAME"} = $cur_hash{"BYLS_DISPLAY_NAME"}." ".$partition_type;
}
# Based on role, populate the array
$_ = $role;
SWITCH:
{
/host/i && do {
if (lc($cur_hash{"BYLS_LS_HOSTNAME"}) ne "na" and $cur_hash{"BYLS_LS_HOSTNAME"} ne "")
{
push ( @hostArray, \%cur_hash);
}
last SWITCH;
};
/guest/i && do {
push ( @guestArray, \%cur_hash);
if ( $self->{VENDOR} ne "VMware" and $self->{VENDOR} ne "Oracle" )
{
foreach my $guest (@guestarray)
{
# Get FQDN for all guests, this needs to be removed when PA provides data
if ( $guest->{"BYLS_IP_ADDRESS"} )
{
$guest->{"BYLS_LS_HOSTNAME"} = OvCommon::getFQDN($guest->{"BYLS_IP_ADDRESS"});
}
}
}
last SWITCH;
};
/respool/i && do {
push ( @respoolArray, \%cur_hash);
last SWITCH;
};
/datastore/i && do {
push ( @datastoreArray, \%cur_hash);
last SWITCH;
};
/virtualapp/i && do{
push ( @virtualapparray, \%cur_hash);
last SWITCH;
};
}
}
}
}
# Populate class attributes
$self->{HOSTLIST} = \@hostArray;
$self->{GUESTLIST} = \@guestArray;
$self->{RESPOOLLIST} = \@respoolArray;
$self->{DATASTORELIST} = \@datastoreArray;
$self->{VIRTUALAPPLIST} = \@virtualapparray;
close(OVCODADUMP);
return 0;
}
# Routine to get the configuration details, check for GBL metrics on host
sub getConfigDetails
{
my $self = shift;
my $dr = $self->{DR};
my %cfghash = ();
{
local $/ = "\n"; # separator is newline
my $VA_Node = OvCommon::GetXplConfigSetting("opsagt", "NGMODE");
if($VA_Node eq "true")
{
my %GblHash = ();
open (VACONFIG, "ovcodautil -ds scope -o GLOBAL -m GBL_NODENAME -last -flat 2>&1 |") or return -1;
while ( <VACONFIG> )
{
chomp;
my @fields = split (/\s*\:\s*/,$_);
$GblHash{$fields[0]} = $fields[1];
}
close (VACONFIG);
my $opcnode = $GblHash{"GBL_NODENAME"};
$self->{HOSTNAME} = OvCommon::getFQDN($opcnode);
$self->{HOSTTYPE} = "Hosts";
$self->{GUESTTYPE} = "Virtual Machines";
$self->{VENDOR} = "VMware";
$self->{TYPE} = "ESX/ESXi";
$self->{PRODUCT} = "ESX/ESXi";
$self->{HYPERVISORTYPE} = "vmware_hypervisor";
$self->{VERSION} = "version unknown";
$self->{ROLE} = "HP Operations Agent";
$self->{PROXYPRODUCT} = "HP Operations Agent";
return 0;
}
open (DUMPCONFIG, "ovcodautil -ds scope -o CONFIGURATION -m GBL_LS_TYPE,GBL_LS_ROLE,GBL_OSRELEASE,GBL_MACHINE_MODEL,GBL_SYSTEM_ID,GBL_DISTRIBUTION -last -flat 2>&1 |") or return -1;
while ( <DUMPCONFIG> )
{
chomp;
my @fields = split (/ +: +/, $_, 2);
$cfghash{$fields[0]} = $fields[1];
}
close (DUMPCONFIG);
}
# check for various vendor types here and get vendor-specific details for later use.
my $opcnode = OvCommon::GetXplConfigSetting("eaagt",qw/OPC_NODENAME/);
$self->{HOSTNAME} = OvCommon::getFQDN($opcnode);
$self->{HOSTTYPE} = "Hosts";
$self->{GUESTTYPE} = "Virtual Machines";
$_ = lc($cfghash{GBL_LS_TYPE});
SWITCH:
{
/vmware/i && do {
$self->{VENDOR} = "VMware";
$self->{TYPE} = "ESX/ESXi";
$self->{PRODUCT} = "ESX/ESXi";
$self->{HYPERVISORTYPE} = "vmware_hypervisor";
$self->{VERSION} = "version unknown";
if ( lc($cfghash{GBL_LS_ROLE}) eq "proxy" ) {
$self->{ROLE} = "vMA";
$self->{PROXYPRODUCT} = "vMA";
}
last SWITCH;
};
/hyper-v/i && do {
$self->{VENDOR} = "Microsoft";
$self->{PRODUCT} = "Hyper-V";
$self->{TYPE} = "Hyper-V";
$self->{VERSION} = " Windows Server 2008(v".$cfghash{GBL_OSRELEASE}.") ";
$self->{HYPERVISORTYPE} = "microsoft_hypervisor";
if ( lc($cfghash{GBL_LS_ROLE}) eq "host" )
{
$self->{ROLE} = "hypervHost";
}
last SWITCH;
};
/hpvm/i && do {
$self->{VENDOR} = "Hewlett-Packard";
$self->{TYPE} = "HPVM";
$self->{PRODUCT} = "HPVM";
$self->{VERSION} = "HP-UX ".$cfghash{GBL_OSRELEASE};
$self->{HYPERVISORTYPE} = "hpvm_hypervisor";
if ( lc($cfghash{GBL_LS_ROLE}) eq "host" )
{
$self->{ROLE} = "hpvmHost";
$self->{MACHINEMODEL} = $cfghash{GBL_MACHINE_MODEL};
}
last SWITCH;
};
/kvm/i && do {
$self->{VENDOR} = "RedHat";
$self->{TYPE} = "KVM";
$self->{PRODUCT} = "KVM";
$self->{VERSION} = "RHEL ".$cfghash{GBL_OSRELEASE};
$self->{HYPERVISORTYPE} = "kvm_hypervisor";
if ( lc($cfghash{GBL_LS_ROLE}) eq "host" )
{
$self->{ROLE} = "kvmHost";
$self->{MACHINEMODEL} = $cfghash{GBL_MACHINE_MODEL};
}
last SWITCH;
};
/xen/i && do {
$self->{VENDOR} = "SLES";
# $self->{VENDOR} =$cfghash{GBL_DISTRIBUTION};
$self->{TYPE} = "XEN";
$self->{PRODUCT} = "XEN";
$self->{VERSION} = $self->{VENDOR}.$cfghash{GBL_OSRELEASE};
$self->{HYPERVISORTYPE} = "xen_hypervisor";
if ( lc($cfghash{GBL_LS_ROLE}) eq "host" )
{
$self->{ROLE} = "XenHost";
$self->{MACHINEMODEL} = $cfghash{GBL_MACHINE_MODEL};
}
last SWITCH;
};
/zone/i && do {
$self->{VENDOR} = "Oracle";
$self->{TYPE} = "Zone";
my ($majorver, $minorver) = split /\./, $cfghash{GBL_OSRELEASE};
$self->{VERSION} = "Solaris ".$minorver." Container";
$self->{PRODUCT} = "Solaris Containers";
$self->{HOSTTYPE} = "(Global Zones)";
$self->{GUESTTYPE} = "(Non-Global Zones)";
if ( lc($cfghash{GBL_LS_ROLE}) eq "host" )
{
$self->{ROLE} = "globalZone";
$self->{MACHINEMODEL} = $cfghash{GBL_MACHINE_MODEL};
}
last SWITCH;
};
/lpar/i && do {
$self->{VENDOR} = "IBM";
$self->{TYPE} = "LPAR/WPAR";
$self->{VERSION} = "AIX";
$self->{PRODUCT} = "LPAR";
$self->{HOSTTYPE} = "Frames";
$self->{HYPERVISORTYPE} = "ibm_power_hypervisor";
$self->{GUESTTYPE} = "and WPARs";
$self->{SYSTEMNAME} = $cfghash{GBL_SYSTEM_ID};
#$self->{HOSTNAME} = OvVirtual::GetLPARFrameID();
if ( lc($cfghash{GBL_LS_ROLE}) eq "peer" )
{
$self->{ROLE} = "LPARFrame";
$self->{MACHINEMODEL} = $cfghash{GBL_MACHINE_MODEL};
}
last SWITCH;
};
}
return 0;
}
sub genTopXml
{
my $self = shift;
my $dr = $self->{DR};
# define VirtualInfrastructure element
$dr->DefineInstance ("hVI","VirtualizationInfrastructure",true);
# create top-level service
$dr->DefineInstance ("hVV","Class_VirtualizationVendor",true); # true - virtual
# check for vendor types
$dr->AddAttr("hVV", "vendorname", $self->{VENDOR});
$dr->CreateService ("hVV");
$dr->CreateComponent("hVI", "hVV");
}
# Routine to generate XML for Proxy, ex: VMware vMA
sub genProxyXml
{
my $self = shift;
my $dr = $self->{DR};
# create element pertaining to HypervisorHostCollection
if (($self->{ROLE} eq "vMA") && ($self->{VENDOR} eq "VMware"))
{
$dr->DefineInstance ("hMPC","Class_MonitoringProxyCollection",true); # true - virtual
$dr->AddAttr("hMPC", "vendorname", "VMware");
$dr->AddAttr("hMPC", "proxyproductname", "vSphere Management Assistants");
$dr->AddAttr("hMPC", "type", $self->{VENDOR});
$dr->CreateService ("hMPC");
$dr->CreateComponent("hVV", "hMPC");
# create element pertaining to Proxy
$dr->DefineInstance ("hProxy".$self->{HOSTNAME},"Class_MonitoringProxy", false,$self->{HOSTNAME}); # true - virtual
# all attributes are required here
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "vendorname", $self->{VENDOR});
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "proxyproductname", "vSphere Management Assistant");
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "proxyname", $self->{PROXYPRODUCT});
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "hostname", $self->{HOSTNAME});
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "detail", ( ($self->{"BYLS_MACHINE_MODEL"} and lc($self->{"BYLS_MACHINE_MODEL"}) ne "na")? ($self->{"BYLS_MACHINE_MODEL"}) : "(System details unknown)"));
# set parent for Host element as hProxy name
$dr->CreateService ("hProxy".$self->{HOSTNAME});
$dr->CreateComponent("hMPC", "hProxy".$self->{HOSTNAME});
my $lhost = OvCommon::getFQDN($self->{"HOSTNAME"});
$dr->DefineInstance ("hHostSI".$lhost,"Class_NodeSystem",false, $lhost, "SI@@");
$dr->CreateDependent("hProxy".$self->{HOSTNAME}, "hHostSI".$lhost);
#code to set "OPC_SET_VISPI_SI"
my $vispi_si = OvCommon::GetXplConfigSetting("eaagt", "OPC_SET_VISPI_SI");
if ( $vispi_si == 0 )
{
my $result = `ovconfchg -ns eaagt -set OPC_SET_VISPI_SI 30m`;
}
#code to set path for vMA 4.1 ( to over come LD_LIBRARY path issue)
my $vmaversion = OvCommon::GetvMAVersion;
if ( $vmaversion >= 4.1)
{
my $vispi_vma41_path = OvCommon::GetXplConfigSetting("ctrl.env.append", "PATH");
if ( $vispi_vma41_path !~ /\/opt\/vmware\/vma\/lib64:\/opt\/vmware\/vma\/lib/ )
{
my $result = `ovconfchg -ns ctrl.env.append -set PATH /opt/vmware/vma/lib64:/opt/vmware/vma/lib`;
}
}
}
if (($self->{ROLE} eq "HP Operations Agent") && ($self->{VENDOR} eq "VMware"))
{
my $oacoreid =`ovcoreid`;
$oacoreid=~ s/^\s+//;
$oacoreid=~ s/\s+$//;
$dr->DefineInstance ("hMPC","Class_MonitoringProxyCollection",true); # true - virtual
$dr->AddAttr("hMPC", "vendorname", "VMware");
$dr->AddAttr("hMPC", "proxyproductname", "HP Operations Agent");
$dr->AddAttr("hMPC", "type", $self->{VENDOR});
$dr->CreateService ("hMPC");
$dr->CreateComponent("hVV", "hMPC");
# create element pertaining to Proxy
$dr->DefineInstance ("hProxy".$self->{HOSTNAME},"Class_MonitoringProxy", false, $self->{HOSTNAME}); # true - virtual
# all attributes are required here
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "vendorname", $self->{VENDOR});
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "proxyproductname", "HP Operations Agent");
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "proxy_role", "VA");
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "oa_coreid", $oacoreid);
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "proxyname", $self->{PROXYPRODUCT});
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "hostname", $self->{HOSTNAME});
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "detail", ( ($self->{"BYLS_MACHINE_MODEL"} and lc($self->{"BYLS_MACHINE_MODEL"}) ne "na")? ($self->{"BYLS_MACHINE_MODEL"}) : "(System details unknown)"));
# set parent for Host element as hProxy name
$dr->CreateService ("hProxy".$self->{HOSTNAME});
$dr->CreateComponent("hMPC", "hProxy".$self->{HOSTNAME});
my $lhost = OvCommon::getFQDN($self->{"HOSTNAME"});
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "vafqdn", $lhost);
#$dr->DefineInstance ("hHostSI".$lhost,"Class_NodeSystem",false, $lhost, "SI@@");
#$dr->CreateDependent("hProxy".$self->{HOSTNAME}, "hHostSI".$lhost);
}
if (($self->{ROLE} eq "LPARFrame") && ($self->{VENDOR} eq "IBM")) {
my @hostarray = @{$self->{HOSTLIST} };
my $frameid = "";
for my $host (@hostarray)
{
$frameid= $host->{"BYLS_LS_HOSTNAME"};
break;
}
#my $lhost = OvCommon::getFQDN($self->{"SYSTEMNAME"});
my $oacoreid =`ovcoreid`;
chomp($oacoreid);
$dr->DefineInstance ("hMPC","Class_MonitoringProxyCollection",true); # true - virtual
$dr->AddAttr("hMPC", "vendorname", "IBM");
$dr->AddAttr("hMPC", "proxyproductname", "HP Operations Agent");
$dr->AddAttr("hMPC", "type", $self->{VENDOR});
$dr->CreateService ("hMPC");
$dr->CreateComponent("hVV", "hMPC");
# create element pertaining to Proxy
#$dr->DefineInstance ("hProxy".$self->{SYSTEMNAME},"Class_MonitoringProxy", false, $lhost); # true - virtual
$dr->DefineInstance ("hProxy".$self->{HOSTNAME},"Class_MonitoringProxy", false,$self->{HOSTNAME}); # true - virtual
# all attributes are required here
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "vendorname", $self->{VENDOR});
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "proxyproductname", "HP Operations Agent");
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "proxyname", "HP Operations Agent");
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "proxy_role", "ibm_lpar");
if ($frameid && ($frameid ne "na"))
{
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "frameid", $frameid);
}
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "hostname", $self->{HOSTNAME});
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "oa_coreid", $oacoreid);
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "detail", "Config LPAR ".$self->{HOSTNAME}." proxy for monitoring frame ".$frameid." and partitions thereon.");
$dr->AddAttr("hProxy".$self->{HOSTNAME}, "mon_lpar", $lhost);
# set parent for Host element as hProxy name
$dr->CreateService ("hProxy".$self->{HOSTNAME});
$dr->CreateComponent("hMPC", "hProxy".$self->{HOSTNAME});
# set dependency to partition in SI SPI map
$dr->DefineInstance ("hHostSI".$lhost,"Class_NodeSystem",false, $lhost, "SI@@");
$dr->CreateDependent("hProxy".$self->{HOSTNAME}, "hHostSI".$lhost);
# set dependency to Frame
$dr->DefineInstance ("hFrame_".$self->{HOSTNAME},"Class_HypervisorHost",true);
$dr->CreateDependent("hProxy".$self->{HOSTNAME}, "hFrame_".$frameid);
}
}
# Routine to generate XML for Hosts and Root partitions
# modified to generate Cluster related elements
sub genHostXml
{
my $self = shift;
my $dr = $self->{DR};
my @hostarray = @{ $self->{HOSTLIST} };
return unless ( scalar(@hostarray) );
# create element pertaining to HypervisorHostCollection
$dr->DefineInstance ("hHHC","Class_HypervisorHostCollection",true); # true - virtual
$dr->AddAttr("hHHC", "vendorname", $self->{VENDOR});
$dr->AddAttr("hHHC", "hosttype", $self->{HOSTTYPE});
$dr->AddAttr("hHHC", "productname", $self->{PRODUCT});
$dr->CreateService ("hHHC");
$dr->CreateComponent("hVV", "hHHC");
if (lc($self->{VENDOR}) eq "vmware")
{
# create element pertaining to VMware VCenter Collection
$dr->DefineInstance ("hVMC","Class_VirtualManagementCenters",true); # true - virtual
$dr->AddAttr("hVMC", "vendorname", $self->{VENDOR});
$dr->AddAttr("hVMC", "vmgmttype", "Virtual Centers");
$dr->CreateService ("hVMC");
$dr->CreateComponent("hVV", "hVMC");
# create element pertaining to VMware DataCenterCollection
$dr->DefineInstance ("hVOC","Class_VirtualOrganizingCenters",true); # true - virtual
$dr->AddAttr("hVOC", "vendorname", $self->{VENDOR});
$dr->AddAttr("hVOC", "orgcentertype", "Data Centers");
$dr->CreateService ("hVOC");
$dr->CreateComponent("hVV", "hVOC");
# create element pertaining to Class_ComputeResourceClusters (Collection class)
$dr->DefineInstance ("hCRC","Class_ComputeResourceClusters",true); # true - virtual
$dr->AddAttr("hCRC", "vendorname", $self->{VENDOR});
$dr->CreateService ("hCRC");
$dr->CreateComponent("hVV", "hCRC");
}
my $VMC_class=0;
my @hmc_list;
my %clusteruuidlist = (); # Hash with clustername as key and clusteruuid as value
foreach my $host (@hostarray)
{
my $uuID = "h".$host->{"BYLS_LS_UUID"};
my $FullHostName = $host->{"BYLS_LS_HOSTNAME"};
if ($host->{"BYLS_LS_HOSTNAME"})
{
if (lc($host->{"BYLS_LS_HOSTNAME"}) ne "na" and lc($host->{"BYLS_LS_OSTYPE"}) ne "frame")
{
$dr->DefineInstance($uuID, "Class_HypervisorHost", false, $FullHostName, "VI@@"); # true - virtual
}
else
{
$dr->DefineInstance($uuID, "Class_HypervisorHost", true); # true - virtual
}
}
else
{
$dr->DefineInstance($uuID, "Class_HypervisorHost", false, OvCommon::GetXplConfigSetting("eaagt",qw/OPC_NODENAME/), "VI@@"); # true - virtual
}
my $hostname;
$dr->AddAttr($uuID, "uuid", $host->{"BYLS_LS_UUID"});
$dr->AddAttr($uuID, "vendorname", $self->{VENDOR});
$dr->AddAttr($uuID, "productname", $host->{BYLS_LS_OSTYPE});
$dr->AddAttr($uuID, "productversion", $self->{TYPE}." (".$self->{VERSION}.")");
$dr->AddAttr($uuID, "details", ( ($host->{"BYLS_MACHINE_MODEL"} and lc($host->{"BYLS_MACHINE_MODEL"}) ne "na")? ($host->{"BYLS_MACHINE_MODEL"}) : "(System details unknown)"));
if ( $host->{"BYLS_LS_HOSTNAME"} and lc($host->{"BYLS_LS_HOSTNAME"}) ne "na")
{
$dr->AddAttr($uuID, "hostname", $FullHostName);
}
elsif ($host->{"BYLS_IP_ADDRESS"} ne "na" and $host->{"BYLS_IP_ADDRESS"})
{
$hostname = OvCommon::getFQDN($host->{"BYLS_IP_ADDRESS"});
$dr->AddAttr($uuID, "hostname", $hostname);
$dr->AddAttr($uuID, "lsip", $hostname);
}
else
{
$dr->AddAttr($uuID, "hostname", "(host unknown)");
}
if (lc($self->{VENDOR}) eq "vmware")
{
# Check for vCenter details
my $vchost="";
my $dcname="";
my $clusname="";
if ($host->{"BYLS_VC_IP_ADDRESS"} and $host->{"BYLS_VC_IP_ADDRESS"} ne "na")
{
$vchost = OvCommon::getFQDN($host->{"BYLS_VC_IP_ADDRESS"});
$dr->AddAttr($uuID, "vcip", $vchost);
$dr->DefineInstance ("hvCenter".$vchost,"Class_VirtualManagementCenter",false,$vchost); # true - virtual
$dr->AddAttr("hvCenter".$vchost, "vendorname", $self->{VENDOR});
$dr->AddAttr("hvCenter".$vchost, "productname", $self->{TYPE});
$dr->AddAttr("hvCenter".$vchost, "vmgmttype", "vCenter");
$dr->AddAttr("hvCenter".$vchost, "vmgmtname", $vchost);
$dr->CreateService("hvCenter".$vchost);
$dr->CreateComponent("hVMC", "hvCenter".$vchost);
}
# Check for Data Center details
if ($host->{"BYLS_DATACENTER_NAME"} and $host->{"BYLS_DATACENTER_NAME"} ne "na")
{
my $dccompletepath, $dcpath;
if ($self->{ROLE} eq "HP Operations Agent")
{
$dcname = $host->{"BYLS_DATACENTER_NAME"};
$dccompletepath = $dcname;
}
else
{
($dcname, $dcpath) = split /\//, $host->{"BYLS_DATACENTER_NAME"}, 2;
$dccompletepath = $dcpath.$dcname;
}
$dr->AddAttr($uuID, "dcname", $dcname);
$dr->DefineInstance ("hDatacenter".$dcname,"Class_VirtualOrganizingCenter",true); # true - virtual
$dr->AddAttr("hDatacenter".$dcname, "orgcentername", $dcname);
$dr->AddAttr("hDatacenter".$dcname, "orgcentertype", "DC");
$dr->AddAttr("hDatacenter".$dcname, "orgcenterpath", $dccompletepath);
$dr->AddAttr("hDatacenter".$dcname, "vcname", (($vchost ne "na")? ($vchost) : "(vCenter unknown)"));
$dr->AddAttr("hDatacenter".$dcname, "vendorname", "VMware");
$dr->AddAttr("hDatacenter".$dcname, "productname", "vCenter");
$dr->AddAttr("hDatacenter".$dcname, "location", (($vchost ne "na")? ($vchost) : "(host unknown)"));
$dr->CreateService("hDatacenter".$dcname);
$dr->CreateComponent("hVOC", "hDatacenter".$dcname);
if ( $vchost ne "" )
{
$dr->CreateDependent("hvCenter".$vchost, "hDatacenter".$dcname);
}
}
if (($host->{"BYLS_CLUSTER_NAME"} ne "N/A") and ($host->{"BYLS_CLUSTER_NAME"} ne "na") and (OvCommon::getFQDN($host->{"BYLS_CLUSTER_NAME"}) ne $FullHostName ))
{
$clusname = $host->{"BYLS_CLUSTER_NAME"};
$dr->AddAttr($uuID, "clustername", $clusname);
$dr->DefineInstance ("hCluster".$clusname,"Class_ComputeResourceCluster",true); # true - virtual
$dr->AddAttr("hCluster".$clusname, "vendorname", "VMware");
$dr->AddAttr("hCluster".$clusname, "clustername", $clusname);
my $cluster_uuid;
if($self->{ROLE} eq "HP Operations Agent")
{
#Reconstructing UUID for cluster
$cluster_uuid = $host->{"BYLS_LS_PARENT_UUID"}.":".$dcname;
$dr->AddAttr("hCluster".$clusname, "datacenter", $dcname);
}
else
{
$cluster_uuid = $clusname;
if ( $dcname ne "" )
{
$cluster_uuid = $dcname."_".$cluster_uuid;
$dr->AddAttr("hCluster".$clusname, "datacenter", $dcname);
}
else
{
$dr->AddAttr("hCluster".$clusname, "datacenter", "ha_datacenter");
}
if ( $vchost ne "" )
{
$cluster_uuid = $vchost."_".$cluster_uuid;
}
}
$dr->AddAttr("hCluster".$clusname, "uuid", $cluster_uuid);
$dr->CreateService("hCluster".$clusname);
$dr->CreateComponent("hCRC","hCluster".$clusname);
$clusteruuidlist{$clusname} = $cluster_uuid;
}
$dr->AddAttr($uuID, "datacenter", (($dcname eq "")? "ha_datacenter" : $dcname));
$dr->AddAttr($uuID, "lsstate",$host->{"BYLS_LS_STATE"});
$dr->CreateService($uuID);
$dr->CreateComponent("hHHC",$uuID);
# Check DC level to create dependency for host
if ( $clusname ne "" )
{
$dr->CreateDependent("hCluster".$clusname, $uuID);
}
if ( $dcname ne "" )
{
if ( $clusname ne "" )
{
$dr->CreateDependent("hDatacenter".$dcname, "hCluster".$clusname);
}
else
{
$dr->CreateDependent("hDatacenter".$dcname, $uuID);
}
}
}
elsif ( $self->{VENDOR} eq "IBM" )
{
# if IBM, create all HMC and show relation with frames
my $opcnode = OvCommon::GetXplConfigSetting("eaagt",qw/OPC_NODENAME/);
$self->{HOSTNAME} = OvCommon::getFQDN($opcnode);
if ( $host->{"BYLS_MGMT_IP_ADDRESS"} )
{
if ( !$VMC_class )
{
# create element pertaining to IBM HMC Collection
$dr->DefineInstance ("hVMC","Class_VirtualManagementCenters",true); # true - virtual
$dr->AddAttr("hVMC", "vendorname", $self->{VENDOR});
$dr->AddAttr("hVMC", "vmgmttype", "Hardware Management Consoles");
$dr->CreateService ("hVMC");
$dr->CreateComponent("hVV", "hVMC");
$VMS_class=1;
}
my @match_lines = grep (/$host->{"BYLS_MGMT_IP_ADDRESS"}/, @hmc_list);
if ( scalar(@match_lines) )
{
$dr->CreateDependent("hHMC".$host->{"BYLS_MGMT_IP_ADDRESS"}, $uuID);
}
else
{
$dr->DefineInstance ("hHMC".$host->{"BYLS_MGMT_IP_ADDRESS"},"Class_VirtualManagementCenter",false,$host->{"BYLS_MGMT_IP_ADDRESS"}); # true - virtual
$dr->AddAttr("hHMC".$host->{"BYLS_MGMT_IP_ADDRESS"}, "vendorname", $self->{VENDOR});
$dr->AddAttr("hHMC".$host->{"BYLS_MGMT_IP_ADDRESS"}, "productname", $self->{TYPE});
$dr->AddAttr("hHMC".$host->{"BYLS_MGMT_IP_ADDRESS"}, "vmgmttype", "HMC");
$dr->AddAttr("hHMC".$host->{"BYLS_MGMT_IP_ADDRESS"}, "vmgmtname", $host->{"BYLS_MGMT_IP_ADDRESS"});
$dr->CreateService("hHMC".$host->{"BYLS_MGMT_IP_ADDRESS"});
$dr->CreateComponent("hVMC", "hHMC".$host->{"BYLS_MGMT_IP_ADDRESS"});
$dr->CreateDependent("hHMC".$host->{"BYLS_MGMT_IP_ADDRESS"}, $uuID);
push @hmc_list, $host->{"BYLS_MGMT_IP_ADDRESS"};
}
}
$self->{PROXYPRODUCT} = \@hmc_list;
$dr->AddAttr($uuID, "lsstate",$host->{"BYLS_LS_STATE"});
$dr->AddAttr($uuID, "hmcname",$host->{"BYLS_MGMT_IP_ADDRESS"});
$dr->AddAttr($uuID, "mon_lpar",$self->{HOSTNAME});
$dr->CreateService($uuID);
$dr->CreateComponent("hHHC",$uuID);
}
else
{
# other virtualization
$dr->AddAttr($uuID, "lsstate",$host->{"BYLS_LS_STATE"});
$dr->CreateService($uuID);
$dr->CreateComponent("hHHC",$uuID);
$dr->DefineInstance("hHostSI","Class_NodeSystem",false, $FullHostName, "SI@@");
$dr->CreateDependent($uuID, "hHostSI");
}
# create hypervisor element
if ( ($self->{VENDOR} ne "Oracle") )
{
$self->genRootPartitionXml($host->{"BYLS_LS_UUID"}, $FullHostName, $uuID,$host->{"BYLS_CLUSTER_NAME"});
}
}
$self->{CLUSTERUUIDLIST} = \%clusteruuidlist;
# print %clusteruuidlist, "\n";
}
# Routine to generate XML for Root partition
sub genRootPartitionXml
{
my ($self, $uuid, $fullhostname, $hostuuID, $clusterName) = @_;
my $dr = $self->{DR};
# create element pertaining to Root partition
my $rootpartitionuuID;
$rootpartitionuuID ="hRootPartition".$uuid;
$dr->DefineInstance($rootpartitionuuID, "Class_HypervisorRootPartition", false, $fullhostname); # true- virtual
# all attributes are required here
$dr->AddAttr($rootpartitionuuID, "hypervisortype", $self->{PRODUCT});
$dr->AddAttr($rootpartitionuuID, "productname", $self->{HYPERVISORTYPE});
$dr->AddAttr($rootpartitionuuID, "location", $fullhostname);
$dr->AddAttr($rootpartitionuuID, "hostname", $fullhostname);
if (($clusterName ne "na") and (OvCommon::getFQDN($clusterName) ne $fullhostName ))
{
$dr->AddAttr($rootpartitionuuID, "clustername",$clusterName);
}
if (lc($self->{VENDOR}) eq "vmware") {
$dr->AddAttr($rootpartitionuuID, "magiccaption", eval {my $z = `ovxplmsg -c $catalog -m 24 -t "Service Console"`;$z =~ s/\\x22/\x22/g;$z =~ s/\\x25/\x25/g;$z =~ s/\\x27/\x27/g;$z =~ s/\\\\/\\/g;$z =~ s/\\\$/@%@%@/g;$z =~ s/(\$[\w_!?]+[\[\{][\w_!?\$]+[\]\}])/$1/eeg;$z =~ s/
(\$[\w_!?^]+)/$1/eeg;$z =~ s/@%@%@/\$/g;$z =~ s/\\x24/\x24/g;chomp($z);return($z);});
} elsif (lc($self->{VENDOR}) eq "microsoft") {
$dr->AddAttr($rootpartitionuuID, "magiccaption", eval {my $z = `ovxplmsg -c $catalog -m 25 -t "Root Partition"`;$z =~ s/\\x22/\x22/g;$z =~ s/\\x25/\x25/g;$z =~ s/\\x27/\x27/g;$z =~ s/\\\\/\\/g;$z =~ s/\\\$/@%@%@/g;$z =~ s/(\$[\w_!?]+[\[\{][\w_!?\$]+[\]\}])/$1/eeg;$z =~ s/(
\$[\w_!?^]+)/$1/eeg;$z =~ s/@%@%@/\$/g;$z =~ s/\\x24/\x24/g;chomp($z);return($z);});
} elsif (lc($self->{VENDOR}) eq "hewlett-packard") {
$dr->AddAttr($rootpartitionuuID, "magiccaption", eval {my $z = `ovxplmsg -c $catalog -m 26 -t "VMM"`;$z =~ s/\\x22/\x22/g;$z =~ s/\\x25/\x25/g;$z =~ s/\\x27/\x27/g;$z =~ s/\\\\/\\/g;$z =~ s/\\\$/@%@%@/g;$z =~ s/(\$[\w_!?]+[\[\{][\w_!?\$]+[\]\}])/$1/eeg;$z =~ s/(
\$[\w_!?^]+)/$1/eeg;$z =~ s/@%@%@/\$/g;$z =~ s/\\x24/\x24/g;chomp($z);return($z);});
} elsif ( (lc($self->{VENDOR}) eq "redhat") || (lc($self->{VENDOR}) eq "sles") || (lc($self->{VENDOR}) eq "ubuntu") ) {
$dr->AddAttr($rootpartitionuuID, "magiccaption", eval {my $z = `ovxplmsg -c $catalog -m 26 -t "VMM"`;$z =~ s/\\x22/\x22/g;$z =~ s/\\x25/\x25/g;$z =~ s/\\x27/\x27/g;$z =~ s/\\\\/\\/g;$z =~ s/\\\$/@%@%@/g;$z =~ s/(\$[\w_!?]+[\[\{][\w_!?\$]+[\]\}])/$1/eeg;$z =~ s/(
\$[\w_!?^]+)/$1/eeg;$z =~ s/@%@%@/\$/g;$z =~ s/\\x24/\x24/g;chomp($z);return($z);});
}
# set parent for Root partition
$dr->CreateService ($rootpartitionuuID);
$dr->CreateComponent($hostuuID, $rootpartitionuuID);
}
# Routine to generate XML for VMs
sub genGuestXml
{
my $self = shift;
my $dr = $self->{DR};
my @guestarray = @{ $self->{GUESTLIST} };
return unless( scalar(@guestarray) );
my %uuid_maps_rp = %{ $self->{RPUUIDMAPS} };
# create element pertaining to HypervisorClientCollection
$dr->DefineInstance ("hHCC","Class_HypervisorClientCollection",true); # true - virtual
$dr->AddAttr("hHCC", "vendorname", $self->{VENDOR});
$dr->AddAttr("hHCC", "productname", $self->{PRODUCT});
$dr->AddAttr("hHCC", "guesttype", $self->{GUESTTYPE});
$dr->CreateService ("hHCC");
$dr->CreateComponent("hVV", "hHCC");
%vmtype = ( "vmware" => "virtual machine",
"microsoft" => "guest",
"oracle" => "zone",
"hewlett-packard" => "virtual machine",
"redhat" => "virtual machine",
"sles" => "virtual machine",
"ubuntu" => "virtual machine",
"ibm" => "partition");
if ( $self->{PRODUCT} ne "LPAR" )
{
my %LocalZone;
if( ($self->{PRODUCT} eq "Solaris Containers" ) && !($guest->{"BYLS_LS_UUID"}))
{
my @Zonelist = `zoneadm list -p | cut -d ":" -f2,5 `;
if (scalar(@Zonelist))
{
foreach $list (@Zonelist)
{
next if $list =~ /global/;
chomp $list;
($ZoneName,$ZoneUUID) = split(":",$list);
$LocalZone{$ZoneName} = $ZoneUUID;
}
}
}
foreach my $guest (@guestarray)
{
my $uuID = "h".$guest->{"BYLS_LS_NAME"};
$dr->DefineInstance($uuID, "Class_HypervisorClient", true); # true - virtual
$dr->AddAttr($uuID, "vendorname", $self->{VENDOR});
$dr->AddAttr($uuID, "producttype", $self->{PRODUCT});
$dr->AddAttr($uuID, "parentuuid", $guest->{"BYLS_LS_PARENT_UUID"});
$dr->AddAttr($uuID, "parenttype", $guest->{"BYLS_LS_PARENT_TYPE"});
my $host_hostname="(host unknown)";
if ( $guest->{"BYLS_LS_HOST_HOSTNAME"} )
{
$host_hostname = $guest->{"BYLS_LS_HOST_HOSTNAME"};
}
$dr->AddAttr($uuID, "lshostname", $host_hostname);
$dr->AddAttr($uuID, "location", $host_hostname);
$dr->AddAttr($uuID, "vmtype", $vmtype{lc($self->{VENDOR})});
$dr->AddAttr($uuID, "uuid", $guest->{"BYLS_LS_NAME"});
#code changes for VMUUID in case of Solaris and HPVM
if( $self->{PRODUCT} eq "Solaris Containers" )
{
if ($guest->{"BYLS_LS_UUID"})
{
#code changes for converting the BiosUuid in upper case
$dr->AddAttr($uuID, "vmuuid", uc($guest->{"BYLS_LS_UUID"}));
}
else
{
#code changes for converting the BiosUuid in upper case
$dr->AddAttr($uuID, "vmuuid", uc($LocalZone{$guest->{"BYLS_LS_NAME"}}));
}
}
# adding fix for UUID on vMA
elsif ($self->{ROLE} eq "vMA")
{
my ($name,$vmuuid) = split(/:/,uc($guest->{"BYLS_LS_NAME"}));
$dr->AddAttr($uuID, "vmuuid", $vmuuid);
}
else
{
#code changes for converting the BiosUuid in upper case
$dr->AddAttr($uuID, "vmuuid", uc($guest->{"BYLS_LS_UUID"}));
}
#commented the below code as part of fix of
#$dr->AddAttr($uuID, "vmfqdn", $guest->{"BYLS_LS_HOSTNAME"});
if ( lc($self->{VENDOR}) eq "redhat" || lc($self->{VENDOR}) eq "sles" )
{
$dr->AddAttr($uuID, "vmfqdn", ((lc($guest->{"BYLS_LS_HOSTNAME"}) ne "na")?($guest->{"BYLS_LS_HOSTNAME"}) : ($guest->{"BYLS_DISPLAY_NAME"})));
}
else
{
$dr->AddAttr($uuID, "vmfqdn",$guest->{"BYLS_LS_HOSTNAME"});
}
$dr->AddAttr($uuID, "vmname", ((lc($guest->{"BYLS_LS_HOSTNAME"}) ne "na")?($guest->{"BYLS_LS_HOSTNAME"}):cleanupdisplayname($guest->{"BYLS_DISPLAY_NAME"})));
$dr->AddAttr($uuID, "vmos", (($guest->{"BYLS_LS_OSTYPE"} and lc($guest->{"BYLS_LS_OSTYPE"}) ne "na")? ($guest->{"BYLS_LS_OSTYPE"}) : "(OS unknown)"));
$dr->AddAttr($uuID, "lsstate",$guest->{"BYLS_LS_STATE"});
$dr->CreateService($uuID);
$dr->CreateComponent("hHCC",$uuID);
if ( $guest->{"BYLS_LS_PARENT_UUID"} and lc($guest->{"BYLS_LS_PARENT_UUID"}) ne "na" )
{
if ( lc($guest->{"BYLS_LS_PARENT_TYPE"}) eq "respool" and lc($guest->{"BYLS_LS_HOST_HOSTNAME"}) ne "na" )
{
if ($self->{ROLE} eq "vMA")
{
my $parentid_orig = $guest->{"BYLS_LS_PARENT_UUID"};
$guest->{"BYLS_LS_PARENT_UUID"} = $uuid_maps_rp{$parentid_orig};
}
}
$dr->CreateDependent($uuID, "h".$guest->{"BYLS_LS_PARENT_UUID"});
}
}
}
else
{
# For IBM LPAR guests
my @wpararray;
foreach my $guest (@guestarray)
{
next if ($guest->{"BYLS_LS_NAME"} eq "na");
my $opcnode = OvCommon::GetXplConfigSetting("eaagt",qw/OPC_NODENAME/);
$self->{HOSTNAME} = OvCommon::getFQDN($opcnode);
my $uuID = "h".$guest->{"BYLS_LS_NAME"};
$dr->DefineInstance($uuID, "Class_HypervisorClient", true); # true - virtual
$dr->AddAttr($uuID, "vendorname", $self->{VENDOR});
$dr->AddAttr($uuID, "producttype", $self->{PRODUCT});
$dr->AddAttr($uuID, "parentuuid", $guest->{"BYLS_LS_PARENT_UUID"});
$dr->AddAttr($uuID, "parenttype", $guest->{"BYLS_LS_PARENT_TYPE"});
my $host_hostname="(host unknown)";
if ( $guest->{"BYLS_LS_HOST_HOSTNAME"} )
{
$host_hostname = OvCommon::getFQDN($guest->{"BYLS_LS_HOST_HOSTNAME"});
}
$dr->AddAttr($uuID, "lshostname", $guest->{"BYLS_LS_PARENT_UUID"});
$dr->AddAttr($uuID, "vmtype", $vmtype{lc($self->{VENDOR})});
$dr->AddAttr($uuID, "uuid", $guest->{"BYLS_LS_NAME"});
$dr->AddAttr($uuID, "vmuuid", $guest->{"BYLS_LS_NAME"});
## $dr->AddAttr($uuID, "vmfqdn", $guest->{"BYLS_LS_HOSTNAME"});
$dr->AddAttr($uuID, "vmname", cleanupdisplayname($guest->{"BYLS_DISPLAY_NAME"}));
$dr->AddAttr($uuID, "vmos", ( ($guest->{"BYLS_LS_OSTYPE"} and lc($guest->{"BYLS_LS_OSTYPE"}) ne "na")? ($guest->{"BYLS_LS_OSTYPE"}) : "(OS unknown)"));
$dr->AddAttr($uuID, "lsstate",$guest->{"BYLS_LS_STATE"});
$dr->AddAttr($uuID, "mon_lpar", $self->{HOSTNAME});
my @monitor_lpar= split(/\./,$opcnode);
my @lpar_name= split(/\./,$guest->{"BYLS_LS_HOSTNAME"});
if ($monitor_lpar[0] eq $lpar_name[0])
{
$dr->AddAttr($uuID, "config_lpar",TRUE);
if ($guest->{"BYLS_LS_HOSTNAME"} !=~ /\./)
{
$guest->{"BYLS_LS_HOSTNAME"} = $opcnode;
}
}
$dr->AddAttr($uuID, "vmfqdn", $guest->{"BYLS_LS_HOSTNAME"});
$dr->CreateService($uuID);
$dr->CreateComponent("hHCC",$uuID);
if ( $guest->{"BYLS_LS_PARENT_UUID"} and lc($guest->{"BYLS_LS_PARENT_UUID"}) ne "na" )
{
if ( lc($guest->{"BYLS_LS_TYPE"}) eq "sys wpar" )
{
push @wpararray, $guest;
next;
}
$dr->CreateDependent($uuID, "h".$guest->{"BYLS_LS_PARENT_UUID"});
}
}
$self->{WPARLIST} = \@wpararray;
foreach my $guest (@wpararray)
{
my $uuID = "h".$guest->{"BYLS_LS_NAME"};
if ( $guest->{"BYLS_LS_PARENT_UUID"} and lc($guest->{"BYLS_LS_PARENT_UUID"}) ne "na" )
{
$dr->CreateDependent($uuID, "h".$guest->{"BYLS_LS_PARENT_UUID"});
}
}
my $thisLPAR = OvCommon::GetXplConfigSetting("eaagt",qw/OPC_NODENAME/);
my ($guest, @other) = split/\./, $thisLPAR;
$dr->DefineInstance("hHostSI".$thisLPAR, "Class_NodeSystem", false, $thisLPAR, "SI@@");
$dr->CreateDependent("h".$guest, "hHostSI".$thisLPAR);
}
}
# Routine to generate XML for Resource pools
sub genRespoolXml
{
my $self = shift;
my $dr = $self->{DR};
my @respoolarray = @{ $self->{RESPOOLLIST} };
return unless( scalar(@respoolarray) );
my %clusteruuidhash = %{ $self->{CLUSTERUUIDLIST} };
my %uuid_maps_rp = (); # Maps the RP UUID received from PA to a unique UUID when the RP belongs to a cluster
my %uuid_maps_cluid = (); # Maps the RP UUID received from PA to the cluster UUID when the RP belongs to a cluster
if ($self->{ROLE} eq "vMA")
{
# If a resource pool belongs to a cluster, PA will present it with a different UUID for each host belonging to the cluster
# In order to avoid duplicate services for this RP, we remap the UUID of the RP to a unique UUID for this RP/Cluster
# First we remap the top level RPs
my $uuid_update_done="false"; # This flag indicates whether we updated a UUID while running the loop
foreach my $rp (@respoolarray)
{
if((($rp->{"BYLS_LS_PARENT_TYPE"} eq "HOST") ||($rp->{"BYLS_LS_PARENT_TYPE"} eq "CLUSTER")) && ($rp->{"BYLS_CLUSTER_NAME"} ne "N/A") && ($rp->{"BYLS_CLUSTER_NAME"} ne "na"))
{
my $clustername = $rp->{"BYLS_CLUSTER_NAME"};
my $clusteruuid = $clusteruuidhash{$clustername};
if ( $clusteruuid ne undef )
{
# Save original UUID and calculate new UUID
my $uuid_orig = $rp->{"BYLS_LS_UUID"};
my $uuid_new = $rp->{"BYLS_DISPLAY_NAME"}.":".$clusteruuid;
# Map original RP UUID to new RP UUID and cluster UUID
# This will be used for correctly building dependency relationships to this RP
$uuid_maps_rp{$uuid_orig} = $uuid_new;
$uuid_maps_cluid{$uuid_orig} = $clusteruuid;
# Update fields in this RP
$rp->{"BYLS_LS_UUID"} = $uuid_new;
$rp->{"BYLS_LS_PARENT_TYPE"} = "CLUSTER";
$rp->{"BYLS_LS_PARENT_UUID"} = "hCluster".$clustername;
$uuid_update_done="true";
}
}
}
# Next we scan through resource pools to update UUIDs of RPs that are children of an RP whose UUID was previously updated
# If we don't do this, the child RPs will appear as duplicates under the parent RP (one for each host of the cluster)
while ( $uuid_update_done eq "true" )
{
$uuid_update_done="false";
foreach my $rp (@respoolarray)
{
# If this RP was not mapped to a cluster, but the parent was, we need to map it now
my $uuid_orig = $rp->{"BYLS_LS_UUID"};
my $uuid_parent=$rp->{"BYLS_LS_PARENT_UUID"};
if ( ( not exists( $uuid_maps_rp{$uuid_orig} ) ) && exists( $uuid_maps_rp{$uuid_parent} ) )
{
# Save original UUID and calculate new UUID
my $clusteruuid=$uuid_maps_cluid{$uuid_parent};
my $uuid_new = $rp->{"BYLS_DISPLAY_NAME"}.":".$clusteruuid;
# Map original RP UUID to new RP UUID and cluster UUID
# This will be used for correctly building dependency relationships to this RP
$uuid_maps_rp{$uuid_orig} = $uuid_new;
$uuid_maps_cluid{$uuid_orig} = $clusteruuid;
# Update fields in this RP
$rp->{"BYLS_LS_UUID"} = $uuid_new;
$uuid_update_done="true";
}
}
}
}
$self->{RPUUIDMAPS} = \%uuid_maps_rp;
# create element pertaining to HypervisorClientCollection
$dr->DefineInstance ("hRPC","Class_ResourcePools",true); # true - virtual
$dr->AddAttr("hRPC", "vendorname", $self->{VENDOR});
$dr->AddAttr("hRPC", "type", $self->{VENDOR});
$dr->CreateService ("hRPC");
$dr->CreateComponent("hVV", "hRPC");
# Create a service for each RP
foreach my $rp (@respoolarray)
{
my $uuID = "h".$rp->{"BYLS_LS_UUID"};
$dr->DefineInstance($uuID, "Class_ResourcePool", true); # true - virtual
$dr->AddAttr($uuID, "uuid", $rp->{"BYLS_LS_UUID"});
$dr->AddAttr($uuID, "vendorname", $self->{VENDOR});
$dr->AddAttr($uuID, "producttype", $self->{VENDOR});
$dr->AddAttr($uuID, "parentuuid", $rp->{"BYLS_LS_PARENT_UUID"});
$dr->AddAttr($uuID, "parenttype", $rp->{"BYLS_LS_PARENT_TYPE"});
$dr->AddAttr($uuID, "lshostname", OvCommon::getFQDN($rp->{"BYLS_LS_HOST_HOSTNAME"})) if $rp->{"BYLS_LS_HOST_HOSTNAME"};
$dr->AddAttr($uuID, "rpname", cleanupdisplayname($rp->{"BYLS_DISPLAY_NAME"}));
if ( ($rp->{"BYLS_CLUSTER_NAME"} ne "N/A") && ($rp->{"BYLS_CLUSTER_NAME"} ne "na") )
{
$dr->AddAttr($uuID, "rpsource", $rp->{"BYLS_LS_PARENT_TYPE"}." ".$rp->{"BYLS_CLUSTER_NAME"});
}
else
{
$dr->AddAttr($uuID, "rpsource", $rp->{"BYLS_LS_PARENT_TYPE"}." ".$rp->{"BYLS_LS_HOST_HOSTNAME"});
}
$dr->CreateService($uuID);
}
# Create RP to parent relationships and dependencies to clusters
foreach my $rp (@respoolarray)
{
my $uuID = "h".$rp->{"BYLS_LS_UUID"};
if (lc($rp->{"BYLS_LS_PARENT_TYPE"}) eq "respool")
{
if (exists ($self->{RPUUIDMAPS}->{$rp->{"BYLS_LS_PARENT_UUID"}}))
{
# Since parent UUID was mapped to a new UUID, we use this new UUID
$dr->CreateComponent("h".$self->{RPUUIDMAPS}->{$rp->{"BYLS_LS_PARENT_UUID"}}, $uuID);
}
else
{
$dr->CreateComponent("h".$rp->{"BYLS_LS_PARENT_UUID"}, $uuID);
}
}
else
{
$dr->CreateComponent("hRPC",$uuID);
#$dr->CreateDependent($uuID,$rp->{"BYLS_LS_PARENT_UUID"});
$dr->CreateDependent($uuID,"hCluster".$rp->{"BYLS_CLUSTER_NAME"});
}
}
}
sub dispXml
{
my $self = shift;
my $dr = $self->{DR};
$dr->OutputResult;
}
sub genDataStoreXml
{
require oasampleutils;
my $self = shift;
my $dr = $self->{DR};
if (($self->{ROLE} eq "HP Operations Agent") && ($self->{VENDOR} eq "VMware"))
{
my $OAMetric = oasampleutils->new("Infrastructure","Node");
my %filter_hash ;
#$filter_hash{"SYSTEM_ROLE"} = "GUEST";
#$filter_hash{"SYSTEM_STATE"} = "on";
#$OAMetric->setfilter(\%filter_hash);
my $policy_interval = 5;
$OAMetric->setinterval($policy_interval);
my $ret = $OAMetric->getassociations("Node","DS");
my %values = %{$ret};
my @datastorearray = @{ $self->{DATASTORELIST} };
return unless( scalar(@datastorearray) );
# create element pertaining to HypervisorClientCollection
$dr->DefineInstance ("hDSC","Class_DatastoreCollection",true); # true - virtual
$dr->AddAttr("hDSC", "vendorname", $self->{VENDOR});
$dr->AddAttr("hDSC", "type", $self->{VENDOR});
$dr->CreateService ("hDSC");
$dr->CreateComponent("hVV", "hDSC");
foreach my $ds(@datastorearray)
{
my $uuID = "h".$ds->{"BYLS_LS_NAME"};
$dr->DefineInstance($uuID, "Class_Datastore", true); # true - virtual
$dr->AddAttr($uuID, "uuid", $ds->{"BYLS_LS_NAME"});
$dr->AddAttr($uuID, "vendorname", $self->{VENDOR});
$dr->AddAttr($uuID, "producttype", $self->{VENDOR});
$dr->AddAttr($uuID, "parentuuid", $ds->{"BYLS_LS_PARENT_UUID"});
#$dr->AddAttr($uuID, "parenttype", $ds->{"BYLS_LS_PARENT_TYPE"});
#$dr->AddAttr($uuID, "lshostname", OvCommon::getFQDN($ds->{"BYLS_LS_HOST_HOSTNAME"})) if $ds->{"BYLS_LS_HOST_HOSTNAME"};
$dr->AddAttr($uuID, "dsname", cleanupdisplayname($ds->{"BYLS_DISPLAY_NAME"}));
$dr->CreateService($uuID);
$dr->CreateComponent("hDSC",$uuID);
if ( $ds->{"BYLS_CLUSTER_NAME"} ne "na" )
{
$dr->AddAttr($uuID, "dssource",$ds->{"BYLS_CLUSTER_NAME"});
$dr->CreateDependent("hCluster".$ds->{"BYLS_CLUSTER_NAME"},$uuID);
}
}
foreach my $key(keys %values)
{
my @VMInfo = split(/:/,$key);
my $VMuuid = $VMInfo[1];
my @DSArray = @{$values{$key}};
foreach my $DS(@DSArray)
{
my @DSInfo = split(/:/,$DS);
my ($DSName,@DSId) = @DSInfo;
my $DSUuid = join(":",@DSId);
$dr->CreateDependent("h".$VMuuid,"h".$DSUuid);
}
}
}
}
sub genVirtualAppXml
{
my $self = shift;
my $dr = $self->{DR};
if (($self->{ROLE} eq "HP Operations Agent") && ($self->{VENDOR} eq "VMware"))
{
my @virtualapparray = @{ $self->{VIRTUALAPPLIST} };
return unless( scalar(@virtualapparray) );
# create element pertaining to VirtualAppCollection
$dr->DefineInstance ("hVAC","Class_VirtualAppCollection",true); # true - virtual
$dr->AddAttr("hVAC", "vendorname", $self->{VENDOR});
$dr->AddAttr("hVAC", "type", $self->{VENDOR});
$dr->CreateService ("hVAC");
$dr->CreateComponent("hVV", "hVAC");
foreach my $va(@virtualapparray)
{
my $uuID = "h".$va->{"BYLS_LS_UUID"};
$dr->DefineInstance($uuID, "Class_VirtualApp", true); # true - virtual
$dr->AddAttr($uuID, "uuid", $va->{"BYLS_LS_UUID"});
$dr->AddAttr($uuID, "vendorname", $self->{VENDOR});
$dr->AddAttr($uuID, "producttype", $self->{VENDOR});
$dr->AddAttr($uuID, "parentuuid", $va->{"BYLS_LS_PARENT_UUID"});
$dr->AddAttr($uuID, "parenttype", $va->{"BYLS_LS_PARENT_TYPE"});
#$dr->AddAttr($uuID, "lshostname", OvCommon::getFQDN($ds->{"BYLS_LS_HOST_HOSTNAME"})) if $ds->{"BYLS_LS_HOST_HOSTNAME"};
#$dr->AddAttr($uuID, "dsname", cleanupdisplayname($ds->{"BYLS_DISPLAY_NAME"}));
$dr->AddAttr($uuID, "vmname",$va->{"BYLS_DISPLAY_NAME"});
$dr->CreateService($uuID);
$dr->CreateComponent("hVAC",$uuID);
}
}
}
sub getProductType {
my $self = shift;
my $uuid = shift;
}
sub disp
{
my $self = shift;
foreach $key (keys(%$self)) {
print $key."::";
if (ref($self->{$key}) =~ /ARRAY.*/) {
my @thisarray = @{ $self->{$key} };
print join("; ",@thisarray), "\n";
}
else {
print $self->{$key}, "\n";
}
}
# print Dumper (%$self);
}
sub FindNumHost
{
my $self = shift;
my $dr = $self->{DR};
my %cfghash = {};
my %logicalhash = {};
my $vima = 0; # To identify vima node
my $hostcount=0; # number of hosts managed by the vima node
local $/ = "\n";
open(DUMPLOGICAL, "ovcodautil -ds scope -o LOGICAL -m BYLS_LS_ROLE -last -flat 2> /dev/null|")
or die "Unable to fetch configuration information\n";
while (<DUMPLOGICAL>) {
chomp;
my $tmp1 = split (/BYLS_LS_ROLE +: +/);
if ($tmp1 == 2) {
if ( @_[1] eq "HOST" ) {
$hostcount = $hostcount + 1;
}
if ( @_[1] eq "PROXY" ) {
$vima=1;
}
}
}
close (DUMPLOGICAL);
if ($vima == 1) {
print "VISPI=$hostcount";
}
# check for hyper-v
else {
open (DUMPCONFIG, "ovcodautil -ds scope -o CONFIGURATION -m GBL_NUM_LS -last -flat 2> /dev/null|")
or die "Unable to fetch configuration information\n";
while (<DUMPCONFIG>) {
chomp;
my $tmp1 = split (/GBL_NUM_LS +: +/);
if ($tmp1 == 2) {
if ( @_[1] >= 1 ) {
$hostcount = 1;
}
}
}
close (DUMPCONFIG);
print "VISPI= $hostcount";
}
}
sub getVATargetList
{
my $self = shift;
my @Targetlist = ();
open TARGETNAMES, "oaconfig -lt|" or return 0;
while (<TARGETNAMES>)
{
my @HostName = split(/:/,$_);
$HostName[0] =~ s/ //g;
if ($HostName[0] !~ /VMWARE/)
{
push @Targetlist, $HostName[0], "vCenter";
}
}
close (TARGETNAMES);
if(scalar(@Targetlist))
{
return @Targetlist;
}
else
{
return 0;
}
}
1;