Dell Server Set Preferred Monitoring with license fallback DSMT

Dell.Operations.Server.TemplateMethod.SetPreferredMonitoringDSMT (DataSourceModuleType)

DSMT for Setting Preferred Monitoring with License fallback mode

Element properties:

Member Modules:

Overrideable Parameters:

Source Code:

<DataSourceModuleType ID="Dell.Operations.Server.TemplateMethod.SetPreferredMonitoringDSMT" Accessibility="Public" Batching="false">

  <Configuration>

    <IncludeSchemaTypes>

      <SchemaType>Windows!Microsoft.Windows.PowerShellSchema</SchemaType>

    </IncludeSchemaTypes>

    <xsd:element minOccurs="1" name="IntervalSeconds" type="xsd:integer"/>

    <xsd:element xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="TimeoutSeconds" type="xsd:int"/>

    <xsd:element minOccurs="1" name="LogLevel" type="xsd:integer"/>

    <xsd:element minOccurs="1" name="SetPreferredMonitoringMethod" type="xsd:string"/>

    <xsd:element minOccurs="0" name="SetUseLicenseFallbackForFreeMethod" type="xsd:boolean"/>

  </Configuration>

  <OverrideableParameters>

    <OverrideableParameter ID="LogLevel" Selector="$Config/LogLevel$" ParameterType="int"/>

    <OverrideableParameter ID="SetPreferredMonitoringMethod" Selector="$Config/SetPreferredMonitoringMethod$" ParameterType="string"/>

    <OverrideableParameter ID="SetUseLicenseFallbackForFreeMethod" Selector="$Config/SetUseLicenseFallbackForFreeMethod$" ParameterType="bool"/>

    <OverrideableParameter ID="IntervalSeconds" Selector="$Config/IntervalSeconds$" ParameterType="int"/>

  </OverrideableParameters>

  <ModuleImplementation Isolation="Any">

    <Composite>

      <MemberModules>

        <DataSource ID="SPM" TypeID="Windows!Microsoft.Windows.TimedPowerShell.DiscoveryProvider">

          <IntervalSeconds>$Config/IntervalSeconds$</IntervalSeconds>

          <SyncTime/>

          <ScriptName>SetPreferredMonitoringDSMT.ps1</ScriptName>

          <ScriptBody><Script>

    # ------------------------------------------------------------------  #

    #  Script : Management Server Connection Script                       #

    #  Author:                    							  #

    #  (c) Copyright &#xA9; 2009&#x2013; 2017 Dell Inc, or its subsidiaries. All Rights Reserved             #

    #  ------------------------------------------------------------------ #



	param($sourceID, $managedEntityID, $IntervalSeconds, $LogLevel, $SetPreferredMonitoringMethod, $SetUseLicenseFallbackForFreeMethod)

    $CONST_INBAND = 'Inband'

    $CONST_OOB = 'OOB'

	$CONST_ISM = 'ISM'

	

    $scriptname = 'SetPreferredMonitoringDSMT.ps1'

    $logDirectory = 'DellPreferredMonitoring_Logs'



    $MSComputerName = (hostname)



    $DebugScript = $false





    # Logging Header

    If ($logLevel -ne 0)

    {

        $TempFolder = [environment]::GetEnvironMentVariable("temp","machine")

        $LogLocation = $TempFolder + "\" + $logDirectory + "\"

        If(!(Test-Path -path($TempFolder)))

        {

            # create the directory if not present

            New-Item $TempFolder -type directory  | Out-Null

        }



        If(!(Test-Path -path($LogLocation)))

        {

            # create the directory if not present

            New-Item $LogLocation -type directory  | Out-Null

        }

        $Global:LogFileLocation = $LogLocation + $scriptname + ".log"

        If(!(Test-Path -path($LogFileLocation)))

        {

            # create the file if it does not exist

            New-Item $LogFileLocation -type file | Out-Null

        }

        Else

        {

            $logFileSize = Get-ChildItem $LogFileLocation | ForEach-Object {($_.Length/1KB)}

            If ($logFileSize -gt 512)

            {

                # existingLogFile is greater than 512 KB

                $archiveTime = Get-Date -f "yyyy-MM-dd_HH.mm"

                Rename-Item $LogFileLocation ("ArchivedLog_" + $scriptname + "_" + $archiveTime + ".log")

                New-Item $LogFileLocation -type file | Out-Null

            }

        }

    }



    # -----------------------------------------------------------------------

    # includes timestamp, msg and supports archiving over 512 KB

    # ------------------------------------------------------------------------

    Function psDebugLog

    {

        param($level, $message)

        if (($level -gt 0) -and ($level -le $logLevel))

        {

            $currentTime = Get-Date -f "yyyy-MM-dd_HH.mm.ss"

            Out-File -FilePath $LogFileLocation -InputObject ($currentTime + " :: " + $message) -Append

        }

    }





    function Write-Info

    {

        param ([string] $msg)

    psDebugLog -level 1 -message $msg

        Write-Host $msg

    }

    function Write-WarningInfo

    {

        param ([string] $msg)

    psDebugLog -level 1 -message $msg

        Write-Host $msg

    }

    function Write-ErrorInfo

    {

        param ([string] $msg)

    psDebugLog -level 1 -message $msg

        Write-Host $msg

    }



# -----------------------------------------------------------------------------------

# Creating new SCOM2012 Module - for connection to 2012 and 2012 task functionality

# -----------------------------------------------------------------------------------

    $scom2012Interface = new-module {

            [object]$connection = $null

            [object]$mgmtGroup = $null

            [string] $state = ''

            [string] $loglocation = '.\test.log'

            [int] $loglevel = 1

            [string] $product = "SCOM 2012"



            function Write-Info

            {

                param ([string] $msg)

                #Write-Host $msg

            }



            Function psDebugLog

            {

                param($level, $message)

                if (($level -gt 0) -and ($level -le $logLevel))

                {

                    $currentTime = Get-Date -f "yyyy-MM-dd_HH.mm.ss"

                    Out-File -FilePath $this.loglocation -InputObject ($currentTime + " :: " + $message) -Append

                }

            }



            function GetConnection()

            {

               $managementServerName = ""

               $persistConnection = $false

               $interactive = $false

               $MachineRegErrorMsg = "Can not find Operations Manager Management Server name for the local machine.";

               $UserRegKeyPath = "HKCU:\software\Microsoft\Microsoft Operations Manager\3.0\User Settings";

               $MachineRegKeyPath = "HKLM:\software\Microsoft\Microsoft Operations Manager\3.0\Machine Settings";

               $UserRegValueName = "SDKServiceMachine";

               $MachineRegValueName = "DefaultSDKServiceMachine";

               $ConnectingMsg = "Connecting to Operations Manager Management Server '{0}'.";

               $ConnectErrorMsg = "Can not connect to Operations Manager Management Server '{0}'.";

               $AccessDeniedErrorMsg = "Access is denied to Operations Manager Management Server '{0}'.";

               $ConnectPromptMsg = "Enter the name of the Operations Manager Management Server to connect to.";

               $ConnectPrompt = "Management Server";

               $serviceNotRunningErrorMsg = "The Data Access service is either not running or not yet initialized. Check the event log for more information.";

               $HostNotFoundErrorMsg = "No such host is known";



               $regKey = $null;

               $regValue = $null;



               # Set the initial server value to the MS argument.

               # If the argument is empty the normal registry lookup sequence will kickin.

               # If the argument is not empty the user will be connected to the specified connection.

               $server = $managementServerName;

               $drive = $null;



               # Get the User Operations Manager Product Registry Key

               if ($server -eq $null -or $server.Length -eq 0)

               {

                   $regValue = Get-ItemProperty -path:$UserRegKeyPath -name:$UserRegValueName -ErrorAction:SilentlyContinue;



                   if ($regValue -ne $null)

                   {

                       $server = $regValue.SDKServiceMachine;

                   }

               }



               if ($server -eq $null -or $server.Length -eq 0)

               {

                   # Get the Machine Operations Manager Product Registry Key if the user setting could not be found.

                   $regValue = Get-ItemProperty -path:$MachineRegKeyPath -name:$MachineRegValueName -ErrorAction:SilentlyContinue;



                   if ($regValue -ne $null)

                   {

                       $server = $regValue.DefaultSDKServiceMachine;

                   }

               }



               # If the default Operations Manager Management Server name can not be found in the registry then default to 'localhost'.

               if ($server -eq $null -or $server.Length -eq 0)

               {

                   psDebugLog -level 1 -message $MachineRegErrorMsg

                   $server = "localhost";

               }



               # Create a connection and make it the current location.

               $this.connection = $null;



               if ($server -ne $null -and $server.Length -gt 0)

               {

                   # Format the connecting message.

                   $msg = $ConnectingMsg -f $server;

                   psDebugLog -level 1 -message $msg



                   # Create the new connection.

                   $this.connection = New-SCOMManagementGroupConnection -ComputerName: $server -PassThru -ErrorAction:Stop

               }

               $this.state = 'connected'

               $this.mgmtGroup = Get-SCOMManagementGroup

               return $this.connection

            }





            function LoadSnapins()

            {

                Import-Module OperationsManager

                $this.state = 'snapins loaded'

            }



            Function GetManagementPacks()

            {

               return (Get-SCManagementPack)

            }



            function InstallManagementPack($ImportPath)

            {

               Import-SCManagementPack $ImportPath -ErrorAction:SilentlyContinue -ErrorVariable v

               #mgmtGroup.ManagementPacks.ImportManagementPack($ImportPath)

               return $v

            }



            function UninstallManagementPack($ManagementPack)

            {

               Remove-SCManagementPack -ManagementPack $ManagementPack -ErrorAction:SilentlyContinue -ErrorVariable v

               return $v

            }



            function GetSCOMInstallDir()

            {

                return $(Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Microsoft Operations Manager\3.0\Setup").InstallDirectory;

            }



            function GetManagementGroup()

            {

                return $this.mgmtGroup

            }

			

			function IsSCOM2012()

			{

				return $true

			}



            function PrintDebug()

            {

                Write-Info -msg ("Product: " + $this.Product)

                Write-Info -msg ("State: " + $this.State)

            }



            Export-ModuleMember -function * -variable *

    } -asCustomObject

    

	$dellMP = new-module {

        function GetInstallDir()

        {

            return $(Get-ItemProperty "HKLM:\SOFTWARE\Dell\Dell Server Management Pack Suites").Path;

        }

        function GetExportDir($suffix)

        {

            $expDir = $(GetInstallDir)

            $expDir += "\ExportDir\" + $suffix



            If(!(Test-Path -path($expDir)))

            {

                # create the directory if not present

                New-Item $expDir -type directory  | Out-Null

            }



            return $expDir;

        }

         function GetImportDir($impSuffix)

        {

            $impDir = $(GetInstallDir)

            $fullPath = get-childitem $impDir -recurse -filter $impSuffix

            if ($fullpath.Count -ne $null) {

                $impDir = $fullpath[0].FullName

            } else {

                $impDir = $fullPath.FullName

            }



            return $impDir;

        }



            Export-ModuleMember -function * -variable *

    } -asCustomObject



    function CreateDiscoveryOverride

    {

        param($ovrdMP, $discovery, $overridename, $discoveryTgtClass, $contextInstance, $overrideParameter, $overrideParameterValue, $overrideModule)

                $discRuleOverrideStatus = $true

                $discRuleOverrideMessage = 'Done'

                if ($discRuleOverrideStatus -eq $true)

                {

                    $discoveryCriteria = New-Object Microsoft.EnterpriseManagement.Configuration.MonitoringDiscoveryCriteria($("Name='{0}'" -f $discovery))

                    $retVal = $discoveryTgtClass.GetMonitoringDiscoveries($discoveryCriteria)

                    if ($retVal -eq $null -or $retVal.Count -le 0)

                    {

                        # Do Error Condition Return

                        $discRuleOverrideStatus = $false

                        $discRuleOverrideMessage = 'Discovery Rule ' + $discovery + ' not found.'

                    }

                    else

                    {

                        $discoveryRef = $retVal[0]

                    }

                }



                if ($discRuleOverrideStatus -eq $true)

                {

                    ###################################################################################

                    # Check if the override already exists.  If yes, update it.  Otherwise, create one

                    ###################################################################################

                    $overrideDisplayName = $overrideName

                    $override = $overrideDisplayName.Replace(" ", [String]::Empty);



                    $discOverride = $ovrdMP.GetOverrides() | where { $_.Name -eq $override }

                    if ($discOverride -eq $null)

                    {

                       $discOverride = New-Object Microsoft.EnterpriseManagement.Configuration.ManagementPackDiscoveryConfigurationOverride($ovrdMP, $override);

                    }

                    write-info -msg "==="

                    write-info -msg $discoveryRef.Name

                    write-info -msg $discoveryTgtClass.Name

                    write-info -msg $overrideDisplayName

                    write-info -msg $overrideParameter

                    write-info -msg $overrideParameterValue

                    write-info -msg $overrideModule

                    write-info -msg "==="



                    $discOverride.Discovery = $discoveryRef

                    $discOverride.Context = $discoveryTgtClass

                    $discOverride.ContextInstance = $contextInstance

                    $discOverride.DisplayName= $overrideDisplayName

                    $discOverride.Parameter= $overrideParameter

                    $discOverride.Value = $overrideParameterValue

                    $discOverride.Module= $overrideModule

                }

                else

                {

                    Write-Info -msg ("ERROR: Discovery Rule Override creation failed!")

                    Write-Info -msg ("ERROR: " + $discRuleOverrideMessage)

                }

    }



    function DeleteManagementPack

    {

        param($deleteMP)

           Write-Info -msg ("Delete Management Pack " + $deleteMP.Name)

           try {

               $v = $scomenv.UninstallManagementPack($deleteMP)

           } catch [Exception] {

              $e = $_

           }

           if ($e -eq $null -or $e.Count -eq 0) 

           {

               Write-Info -msg ("Success")

           } 

           else

           {

                $isReferenced=$e.Exception.InnerException.Message -match "have references to this"

                if($isReferenced -eq $true)

                {

                     Write-Info -msg ("ERROR: "+ $deleteMP.Name+" cannot be deleted as it has references")

                }

                else

                {

                   $msg = getExceptionDetails -except $v

                   if ($msg -notmatch "not present")

                   {

                      Write-Info -msg ("ERROR: There were errors in the command.")

                      Write-Info -msg ("ERROR: " + $msg)

                   }

                }

           }

    }



    # Now, activate the appropriate customObjectmodule (SCOM2012)

    # based on presence detected on mgmtServer



    psDebugLog -level 1 -message  ("----------------------------------------------")

    psDebugLog -level 1 -message  ("Begin of " + $scriptname + " Discovery script. Proposed Monitoring "+$SetPreferredMonitoringMethod + " Fallback "+$SetUseLicenseFallbackForFreeMethod)

    psDebugLog -level 1 -message  ("ComputerName : " + $MSComputerName)

    psDebugLog -level 1 -message  ("ManagedEntityId : " +  $managedEntityID)

    psDebugLog -level 1 -message  ("sourceID : " +  $sourceID)



    $MachineRegKeyPath = "HKLM:\software\Microsoft\Microsoft Operations Manager\3.0\Setup";

    $MachineRegValueName = "SKU";

    $skuName = $null; $skuVersion = $null

    $skuName = Get-ItemProperty -path:$MachineRegKeyPath -name:$MachineRegValueName -ErrorAction:SilentlyContinue;

    $skuVersion = Get-ItemProperty -path:$MachineRegKeyPath -name:"CurrentVersion" -ErrorAction:SilentlyContinue;

    $scomenv = $scom2012Interface

    $scomenv.loglocation = $LogFileLocation

    $scomenv.LogLevel = $LogLevel

    $scomenv.LoadSnapins()

    $scomenv.PrintDebug()

    $scomenv.GetConnection()



    $mpname = 'Dell.PreferredMonitoring.ServerList'

    $mpdesc = 'Dell Preferred Monitoring Server List file'

    $oneDiscoveryTgtClassName = 'Microsoft.Windows.Computer'

    $oneDiscoveryGenClassName = 'Dell.WindowsServer.Server'

    $oneDiscoveryName = 'Dell.WindowsServer.Server.Discovery'

    $oneOverrideName = 'SecureRef-{0}'

    $oneDiscoveryOverrideModule = "DS"

    $oneDiscoveryOverrideParameterName = "DoDiscovery"



    $twoDiscoveryTgtClassName = 'Microsoft.SystemCenter.OOB.SMASHDevice'

    $twoDiscoveryGenClassName = 'Dell.Server'

    $twoDiscoveryName = 'Dell.Server.OOB.ServerDiscovery'

    $twoDiscoveryOverrideParameterName = 'DoDiscovery'

    $twoDiscoveryOverrideModule =  "DS"



	$ismDiscoveryTgtClassName = 'Microsoft.Windows.Computer'

    $ismDiscoveryGenClassName = 'Dell.ManagedServer'

    $ismDiscoveryName = 'Dell.ManagedServer.Discovery'

    $ismDiscoveryOverrideParameterName = "DoDiscovery"

	$ismDiscoveryOverrideModule = "DS"

    

    $inbandOverrideName = 'InBand-Override-{0}'

    $oobOverrideName =    'OutOfBand-Override-{0}'

	$ismOverrideName = 'iSM-Override-{0}'

	

    $mpStore = New-Object Microsoft.EnterpriseManagement.Configuration.IO.ManagementPackFileStore;

    $scomInstallDir = $scomenv.GetSCOMInstallDir()

    $mpStore.AddDirectory($scomInstallDir);

    $mpStore.AddDirectory($dellsuitedir);

    $mpXmlWriter = New-Object Microsoft.EnterpriseManagement.Configuration.IO.ManagementPackXmlWriter($scomInstallDir);



    $mgmtGroup = $scomenv.GetManagementGroup()





    $dellWindowsServerInstances = $null

    $dellOOBServerInstances = $null

	$delliSMServerInstances = $null

    $dellWindowsServerSvcTagHashMap = @{}

    $dellOOBServerSvcTagHashMap = @{}

    $bothInbandAndOOBDiscoveredServersMap = @{}

	$delliSMServerSvcTagHashMap = @{}

	$bothOOBAndiSMDiscoveredServersMap = @{}



    $prev_dellWindowsServerSvcTagHashMap = @{}

    $prev_dellOOBServerSvcTagHashMap = @{}

	$prev_delliSMServerSvcTagHashMap = @{}

    $prev_bothInbandAndOOBDiscoveredServersMap = @{}

    $prev_bothInbandAndOOBDiscoveredServersServiceTagMap = @{}

	$prev_bothOOBAndiSMDiscoveredServersMap = @{}

    $prev_bothOOBAndiSMDiscoveredServersServiceTagMap = @{}



    $prevOverridesMap = @{}

    $prevOverrideContextMap = @{}

    $prevOverrideValueMap = @{}

    $prevOverrideTypeMap = @{}

	

	function SanitizeOverrideName

    {

       param($ovrName)

	   write-info -msg ("Sanitizing Override=" + $ovrName)

       $inbandmatchOvrName = ($ovrName -replace '\{0}', '')

       $inbandmatchOvrName = (($inbandmatchOvrName.Replace(" ", [String]::Empty)) -replace '-', '_')

       return $inbandmatchOvrName

    }

	

	$serverMatrix = @{}

	$prevServerMatrix = @{}

	

	$truth = 1

	$fallse = 0

	$NA = 2

	

	$enum_INBAND = 0

	$enum_OOB = 1

	$enum_ISM = 2



    $CONST_LICENSE_PRIORITY = $enum_OOB

	

	function AddServerTomatrix

	{

		param($serviceTag, $serverType, $context)

		psDebugLog -level 1 -message "MATRIX Service Tag "$serviceTag" Server Type "$serverType

		if($serverMatrix.containskey($serviceTag) -eq $false)

		{

			$temparray = @($NA, $NA, $NA, "","","")

			$serverMatrix.add($serviceTag, $temparray)

		}

		$serverRow = $serverMatrix.$serviceTag

		$serverRow[$serverType]=$truth

		$serverRow[$serverType+3]=$context

	}

	

    #######################################################################################

    #  GetDellInBandServerObjectList

    #######################################################################################



    $oneDiscoveryTgtClassCriteria = New-Object Microsoft.EnterpriseManagement.Configuration.MonitoringClassCriteria($("Name='{0}'" -f $oneDiscoveryTgtClassName));

    $retVal = $mgmtGroup.GetMonitoringClasses($oneDiscoveryTgtClassCriteria)

    if ($retVal -eq $null -or $retVal.Count -le 0)

    {

        # Do Error Condition Return

    }

    $windowsServerClass = $retVal[0]



    $oneDiscoveryGenClassCriteria = New-Object Microsoft.EnterpriseManagement.Configuration.MonitoringClassCriteria($("Name='{0}'" -f $oneDiscoveryGenClassName));

    $retVal = $mgmtGroup.GetMonitoringClasses($oneDiscoveryGenClassCriteria)

    if ($retVal -eq $null -or $retVal.Count -le 0)

    {

        # Do Error Condition Return

    }

    $dellWindowsServerClass = $retVal[0]



    if ($dellWindowsServerClass -ne $null)

    {

        $dellWindowsServerInstCriteria = New-Object Microsoft.EnterpriseManagement.Monitoring.MonitoringObjectCriteria("", $dellWindowsServerClass)

        $dellWindowsServerInstances = $mgmtGroup.GetMonitoringObjects($dellWindowsServerInstCriteria)

    }



    if ($dellWindowsServerInstances -ne $null) 

    {

        Foreach ($server in $dellWindowsServerInstances)

        {

            $property_ServiceTag = $server.GetMonitoringProperties() | where { $_.Name -eq 'ServiceTag' }

            $serverTag = $server.GetMonitoringPropertyValue($property_ServiceTag)

			#Handling FM Server

			$property_model = $server.GetMonitoringProperties() | where { $_.Name -eq 'Model' }

            $model = $server.GetMonitoringPropertyValue($property_model)

			if($model.Contains("PowerEdge FM"))

			{

				$property_nodeid = $server.GetMonitoringProperties() | where { $_.Name -eq 'NodeID' }

				$nodeid = $server.GetMonitoringPropertyValue($property_nodeid)

				if(!([string]::IsNullOrEmpty($nodeid)))

				{

					$serverTag = $nodeid

				}

			}

            $dellWindowsServerSvcTagHashMap += @{ $serverTag = $server }

			 

			$winDeviceForServer = $null

			$server.GetMonitoringRelationshipObjects() | foreach -process {

				if ($_.SourceMonitoringObject.IsInstanceOf($windowsServerClass))

				{

					$winDeviceForServer = $_.SourceMonitoringObject

				}

			}

			 

			AddServerTomatrix -ServiceTag $serverTag -ServerType $enum_INBAND -context $winDeviceForServer.id

            write-info -msg "inband tag=$serverTag"

			write-info -msg "inband target=$server"

        }

    }





    #######################################################################################

    #  GetDellOOBServerObjectList

    #######################################################################################



    $twoDiscoveryTgtClassCriteria = New-Object Microsoft.EnterpriseManagement.Configuration.MonitoringClassCriteria($("Name='{0}'" -f $twoDiscoveryTgtClassName));

    $retVal = $mgmtGroup.GetMonitoringClasses($twoDiscoveryTgtClassCriteria)

    if ($retVal -eq $null -or $retVal.Count -le 0)

    {

        # Do Error Condition Return

    }

    $smashServerClass = $retVal[0]



    $twoDiscoveryGenClassCriteria = New-Object Microsoft.EnterpriseManagement.Configuration.MonitoringClassCriteria($("Name='{0}'" -f $twoDiscoveryGenClassName));

    $retVal = $mgmtGroup.GetMonitoringClasses($twoDiscoveryGenClassCriteria)

    if ($retVal -eq $null -or $retVal.Count -le 0)

    {

        # Do Error Condition Return

    }

    $dellOOBServerClass = $retVal[0]



    if ($dellOOBServerClass -ne $null)

    {

        $dellOOBServerInstCriteria = New-Object Microsoft.EnterpriseManagement.Monitoring.MonitoringObjectCriteria("", $dellOOBServerClass)

        $dellOOBServerInstances = $mgmtGroup.GetMonitoringObjects($dellOOBServerInstCriteria)



        ############

        # Find All service tags that are common to $dellOOBServerInstances and $dellWindowsServerInstances

        # Prepare a list of those service tags, and for each service tag - get the oob and windows server instance.

        # Only those service tags will be filtered.

        ############

    }



    if ($dellOOBServerInstances -ne $null) 

    {

        Foreach ($server in $dellOOBServerInstances)

        {



            $property_ServiceTag = $server.GetMonitoringProperties() | where { $_.Name -eq 'UID' }

            $serverTag = $server.GetMonitoringPropertyValue($property_ServiceTag)

            $dellOOBServerSvcTagHashMap += @{ $serverTag = $server }

			

			$oobDeviceForServer = $null

			$server.GetMonitoringRelationshipObjects() | foreach -process {

				if ($_.TargetMonitoringObject.IsInstanceOf($smashServerClass))

				{

					$oobDeviceForServer = $_.TargetMonitoringObject

				}

			}

			

			AddServerTomatrix -ServiceTag $serverTag -ServerType $enum_OOB -context $oobDeviceForServer.id

            write-info -msg "oob tag=$serverTag"

        }

    }



	########################################################################################

    #  GetDelliSMServerObjectList

    #######################################################################################



    $ismDiscoveryTgtClassCriteria = New-Object Microsoft.EnterpriseManagement.Configuration.MonitoringClassCriteria($("Name='{0}'" -f $ismDiscoveryTgtClassName));

    $retVal = $mgmtGroup.GetMonitoringClasses($ismDiscoveryTgtClassCriteria)

    if ($retVal -eq $null -or $retVal.Count -le 0)

    {

        # Do Error Condition Return

    }

    $windowsServerClass = $retVal[0]

	$windowsServerInstCriteria = New-Object Microsoft.EnterpriseManagement.Monitoring.MonitoringObjectCriteria("", $windowsServerClass)

    $windowsServerInstances = $mgmtGroup.GetMonitoringObjects($windowsServerInstCriteria)

	

    $ismDiscoveryGenClassCriteria = New-Object Microsoft.EnterpriseManagement.Configuration.MonitoringClassCriteria($("Name='{0}'" -f $ismDiscoveryGenClassName));

    $retVal = $mgmtGroup.GetMonitoringClasses($ismDiscoveryGenClassCriteria)

    if ($retVal -eq $null -or $retVal.Count -le 0)

    {

        # Do Error Condition Return

    }

    $delliSMServerClass = $retVal[0]



    if ($delliSMServerClass -ne $null)

    {

        $delliSMServerInstCriteria = New-Object Microsoft.EnterpriseManagement.Monitoring.MonitoringObjectCriteria("", $delliSMServerClass)

        $delliSMServerInstances = $mgmtGroup.GetMonitoringObjects($delliSMServerInstCriteria)



    }



    if ($delliSMServerInstances -ne $null) 

    {

        Foreach ($server in $delliSMServerInstances)

        {



            $property_ServiceTag = $server.GetMonitoringProperties() | where { $_.Name -eq 'UID' }

            $serverTag = $server.GetMonitoringPropertyValue($property_ServiceTag)

            $property_hostname = $server.GetMonitoringProperties() | where { $_.Name -eq 'DisplayName' }

            $hostname = $server.GetMonitoringPropertyValue($property_hostname)

            #hostname fails in some cases - Display name is better - Health Service Class is the best Solution

            $delliSMServerSvcTagHashMap += @{ $serverTag = $server }

			$winDeviceForServer = $windowsServerInstances | where { $_.DisplayName -eq  $hostname}

			

			#$server.GetMonitoringRelationshipObjects() | foreach -process {

			#	if ($_.SourceMonitoringObject.IsInstanceOf($windowsServerClass))

			#	{

			#		$winDeviceForServer = $_.SourceMonitoringObject

			#	}

			#}

			 

			if(($winDeviceForServer -ne $null) -and ($winDeviceForServer.id -ne $null))

			{

				AddServerTomatrix -ServiceTag $serverTag -ServerType $enum_ISM -context $winDeviceForServer.id

			}

            write-info -msg "iSM tag=$serverTag"

			$winid = $winDeviceForServer.id

			write-info -msg "win class id $winid"

        }

    }



	psDebugLog -level 1 -message "Server Matrix"

	$serverMatrix.Keys | % {"ST = $_ , OmsaOOBiSM = " + $serverMatrix.Item($_) }



    write-info -msg "====================================================="



    #######################################################################################

    # Getting Windows Computer and SMASH device instances

    #######################################################################################

        $windowsServerInstCriteria = New-Object Microsoft.EnterpriseManagement.Monitoring.MonitoringObjectCriteria("", $windowsServerClass)

        $windowsServerInstances = $mgmtGroup.GetMonitoringObjects($windowsServerInstCriteria)

        $smashServerInstCriteria = New-Object Microsoft.EnterpriseManagement.Monitoring.MonitoringObjectCriteria("", $smashServerClass)

        $smashServerInstances = $mgmtGroup.GetMonitoringObjects($smashServerInstCriteria)

        $idList = @{}

        foreach ($i in $smashServerInstances) { $idList += @{ $i.Id = $i } }

        foreach ($i in $windowsServerInstances) { $idList += @{ $i.Id = $i } }





    #######################################################################################

    # Override MP Creation

    #######################################################################################



    $overrideMPDoesNotExist = $true



    $mpReferences = @{

        'OperationsLibrary' = 'Dell.OperationsLibrary.Common'

        'SystemCenter' = 'Microsoft.SystemCenter.Library'

        'SMASH' = 'Microsoft.SystemCenter.OutofBand.SMASH.Library'

        'ServerOOB' = 'Dell.Server.OOB'

		'ServeriSM' = 'Dell.ManagedServer.iSM'

    }



	#Delete the temp trigger MP

	$tmpTriggerMPName = 'Dell.PreferredMonitoring.TaskTrigger'

	$tmpTriggerMP = $scomenv.GetManagementPacks() | where-object { $tmpTriggerMPName -eq $_.Name }

	if($tmpTriggerMP -ne $null)

	{

		DeleteManagementPack -deleteMP $tmpTriggerMP

	}

	

    # Get the Override Management Pack

    $ovrdMP = $scomenv.GetManagementPacks() | where-object { $mpname -eq $_.Name }



    if ($ovrdMP -ne $null)

    {

        $overrideMPDoesNotExist = $false

        $ovrdMP.GetOverrides() | foreach -process {

            if ($prevOverridesMap.ContainsKey($_.Name) -eq $false)

            {

                $prevOverridesMap += @{   $_.Name = $_.ContextInstance }

                $prevOverrideContextMap += @{ $_.Name = $_.Context } 

                $prevOverrideValueMap += @{ $_.Name = $_.Value }

            }

            else

            {

                write-info -msg ("WARNING: Duplicate context instance found " + $_.ContextInstance)

            }

        }

        DeleteManagementPack -deleteMP $ovrdMP

        $ovrdMP = $scomenv.GetManagementPacks() | where-object { $mpname -eq $_.Name }

    }



	psDebugLog -level 1 -message "Prev Override"

	$prevOverridesMap.Keys | % { "Cxt = $_ , OmsaOOBiSM = " + $prevOverridesMap.Item($_) }

	

	function AddServerToprematrix

	{

		param($serviceTag, $serverType, $context, $value)

		#psDebugLog -level 1 -message "in Function PREV_MATRIX Service Tag "+$serviceTag+" Server Type "+$serverType

		if($prevServerMatrix.containskey($serviceTag) -eq $false)

		{

			$temparray = @($NA, $NA, $NA,"","","")

			$prevServerMatrix.add($serviceTag, $temparray)

		}

		$serverRow = $prevServerMatrix.$serviceTag

		if($value -eq $true)

		{

			$serverRow[$serverType]=$truth

		}

		else

		{

			$serverRow[$serverType]=$fallse

		}

		$serverRow[$serverType+3]=$context

	}

	

	foreach ($ovrName in $prevOverridesMap.Keys)

    {

        $ovr = $prevOverridesMap[$ovrName]

    

        $inbandmatchOvrName = SanitizeOverrideName -ovrName $inbandOverrideName

        $oobmatchOvrName = SanitizeOverrideName -ovrName $oobOverrideName

		$ismmatchOvrName = SanitizeOverrideName -ovrName $ismOverrideName

			

        if ( ($ovrName -match $inbandmatchOvrName) -eq $true)

        {

            $serverTag = ($ovrName -replace $inbandmatchOvrName, "")

            $prev_dellWindowsServerSvcTagHashMap += @{ $serverTag = $ovr }

            $prevOverrideTypeMap += @{ $ovrName = $CONST_INBAND }



            write-info -msg ("====== Existing Override ==================")

            write-info -msg ("Inband ServerTag= " + $serverTag)

            write-info -msg ("Inband Override ID= " + $prevOverridesMap[$ovrName])

            write-info -msg ("Inband Override Context= " + $prevOverrideContextMap[$ovrName])

            write-info -msg ("Inband Override Value= " + $prevOverrideValueMap[$ovrName])

            write-info -msg ("Inband Type= " + $prevOverrideTypeMap[$ovrName])

            write-info -msg ("====== Done ==================")

			AddServerToprematrix -serviceTag $serverTag -serverType $enum_INBAND -context $ovr -value $prevOverrideValueMap[$ovrName]

        }

        elseif ( ($ovrName -match $oobmatchOvrName) -eq $true)

        {

            $serverTag = ($ovrName -replace $oobmatchOvrName, "")

            $prev_dellOOBServerSvcTagHashMap += @{ $serverTag = $ovr }

            $prevOverrideTypeMap += @{ $ovrName = $CONST_OOB }

            write-info -msg ("====== Existing Override ==================")

            write-info -msg ("OOB ServerTag= " + $serverTag)

            write-info -msg ("OOB Override ID= " + $prevOverridesMap[$ovrName])

            write-info -msg ("OOB Override Context= " + $prevOverrideContextMap[$ovrName].Name)

            write-info -msg ("OOB Override Value= " + $prevOverrideValueMap[$ovrName])

            write-info -msg ("OOB Type= " + $prevOverrideTypeMap[$ovrName])

            write-info -msg ("====== Done ==================")

			AddServerToprematrix -serviceTag $serverTag -serverType $enum_OOB -context $ovr -value $prevOverrideValueMap[$ovrName]

        }

		elseif ( ($ovrName -match $ismmatchOvrName) -eq $true)

        {

            $serverTag = ($ovrName -replace $ismmatchOvrName, "")

            $prev_delliSMServerSvcTagHashMap += @{ $serverTag = $ovr }

            $prevOverrideTypeMap += @{ $ovrName = $CONST_ISM }

            write-info -msg ("====== Existing Override ==================")

            write-info -msg ("ISM ServerTag= " + $serverTag)

            write-info -msg ("ISM Override ID= " + $prevOverridesMap[$ovrName])

            write-info -msg ("ISM Override Context= " + $prevOverrideContextMap[$ovrName].Name)

            write-info -msg ("ISM Override Value= " + $prevOverrideValueMap[$ovrName])

            write-info -msg ("ISM Type= " + $prevOverrideTypeMap[$ovrName])

            write-info -msg ("====== Done ==================")

			AddServerToprematrix -serviceTag $serverTag -serverType $enum_ISM -context $ovr -value $prevOverrideValueMap[$ovrName]

        }

    }

        

    write-info -msg ("====== Existing Override ==================")

	psDebugLog -level 1 -message "prevServer Matrix"

	$prevServerMatrix.Keys | % {"ST = $_ , OmsaOOBiSM = " + $prevServerMatrix.Item($_) }

	

	function Confirm-WindowsServiceExists

	{  

		param($srvType, $serverId)

		$DellServiceExists = $false

		

		if(($srvType -eq $enum_INBAND) -or ($srvType -eq $enum_ISM))

		{

			$winHost = $windowsServerInstances | where {$_.id -eq $serverId}

			$serverName = $winHost.name

		

			if($srvType -eq $enum_INBAND)

			{

				$OMSAobj = get-wmiobject -class "Dell_SoftwareFeature" -namespace "root\cimv2\dell" -computername $serverName -ErrorAction SilentlyContinue

				if($OMSAobj -ne $null)

				{

                    $omsaversion = $OMSAobj.Version

					psDebugLog -level 1 -message "OMSA installed $omsaversion"

					if($omsaversion -gt "6.2")

					{

						$DellServiceExists =  $true      

						psDebugLog -level 1 -message "OMSA installed on $serverName"

						return $DellServiceExists

					}

				}

                else

                {

                    psDebugLog -level 1 -message "OMSA NOT DETECTED on $serverName"

                }

			}

		

			if($srvType -eq $enum_ISM)

			{

				$ismService = Get-Service -Name "*iDRAC Service Module*" -Computername $serverName -ErrorAction SilentlyContinue

				if($ismService -ne $null)

				{

					$DellServiceExists =  $true      

					psDebugLog -level 1 -message "iSM service Exists on $serverName"

					return $DellServiceExists

				}

                else

                {

                    psDebugLog -level 1 -message "iSM service NOT detected on $serverName"

                }

			}

		}

		elseif($srvType -eq $enum_OOB)

		{

			#OOB case - always return TRUE

			psDebugLog -level 1 -message "Nothing to be verified for OOB"

			$DellServiceExists = $true

		}

		return $DellServiceExists

	}

	

	psDebugLog -level 1 -message "Removing irrelavant Cxt instances"

	$prevServerMatrix.Keys | ForEach-Object {

		psDebugLog -level 1 -message "Current hashtable is:"+$_

		$serverow = $prevServerMatrix.Item($_) 

		#$serverow

		for($i=0;$i -lt 3; $i++)

		{

			if(($serverow[$i] -eq 0) -or ($serverow[$i] -eq 1))

			{

				if($idList.containskey($serverow[$i+3]))

				{

					psDebugLog -level 1 -message $serverow[$i+3]" is available "

				}

				else

				{

					psDebugLog -level 1 -message $serverow[$i+3]" is not available "

					$serverow[$i] = $NA

				}

			}

		}

	}

	

	if ($ovrdMP -eq $null)

    {

        Write-Info -msg ("Creating " + $mpname)

        # Create a new management pack, if not present

        $ovrdMP = New-Object Microsoft.EnterpriseManagement.Configuration.ManagementPack($mpname, $mpdesc, (New-Object Version(1, 0, 0)), $mpStore);

        $mgmtGroup.ImportManagementPack($ovrdMP);

    }



    # Add the MP References. REVISIT: Update References

    foreach ($mpRef in $mpReferences.Keys)

    {

        if ($ovrdMP.References.ContainsKey($mpref) -eq $false)

        {

            # if $ovrdMP.References[$mpref].Version -lt $refmp.Version, update

            $refmp = $scomenv.GetManagementPacks() | where { $_.Name -eq $mpReferences[$mpRef] }

			if($refmp)

			{

            $mprefcons = New-Object Microsoft.EnterpriseManagement.Configuration.ManagementPackReference($refmp, $refmp.Name, $refmp.KeyToken, $refmp.Version);

            $ovrdMP.References.Add($mpref, $mprefcons)

			}

        } elseif ($ovrdMP.References[$mpref].Version -lt $refmp.Version) {

            $refmp = $scomenv.GetManagementPacks() | where { $_.Name -eq $mpReferences[$mpRef] }

			if($refmp)

			{

            $mprefcons = New-Object Microsoft.EnterpriseManagement.Configuration.ManagementPackReference($refmp, $refmp.Name, $refmp.KeyToken, $refmp.Version);

            $ovrdMP.References.Remove($mpref)

            $ovrdMP.References.Add($mpref, $mprefcons)

			}

        }

    }



    $overrideMPDoesNotExist = $false

  

	$DiscoveryTgtClassName = @('Microsoft.Windows.Computer', 'Microsoft.SystemCenter.OOB.SMASHDevice', 'Microsoft.Windows.Computer')

	$DiscoveryTgtSCOMClassName = @($windowsServerClass, $smashServerClass, $windowsServerClass)

	$DiscoveryGenClassName = @('Dell.WindowsServer.Server', 'Dell.Server', 'Dell.ManagedServer')

	$DiscoveryName = @('Dell.WindowsServer.Server.Discovery', 'Dell.Server.OOB.ServerDiscovery', 'Dell.ManagedServer.Discovery')

	$DiscoveryOverrideParameterName = @("DoDiscovery","DoDiscovery","DoDiscovery")

	$DiscoveryOverrideModule = @("DS","DS","DS")

	$overrideDisplayNames = @($inbandOverrideName, $oobOverrideName, $ismOverrideName)

	

	psDebugLog -level 1 -message "BEFORE COMPARE"

	psDebugLog -level 1 -message "Current MATRIX"

	$serverMatrix.Keys | % {"ST = $_ , OmsaOOBiSM = " + $serverMatrix.Item($_) }

	psDebugLog -level 1 -message "PREV MATRIX"

	$prevServerMatrix.Keys | % {"pST = $_ , OmsaOOBiSM = " + $prevServerMatrix.Item($_) }

	

	#Compare the Matrices

	$serverMatrix.Keys | ForEach-Object {

		psDebugLog -level 1 -message "****"

		psDebugLog -level 1 -message "COmparing Matrices for "$_

		$serverow = $serverMatrix.Item($_)

        psDebugLog -level 1 -message "Row for "$_

        psDebugLog -level 1 -message $serverow

        if($prevServerMatrix -ne $null)

        {

            $prevserverow = $prevServerMatrix.$_

			if($prevserverow -ne $null)

			{

				psDebugLog -level 1 -message "Prevrow for "$_

				psDebugLog -level 1 -message $prevserverow

				for($i=0;$i -lt 3; $i++)

				{

					if($prevserverow[$i] -lt $NA)

					{

						$serverow[$i] = $prevserverow[$i]

						$serverow[$i+3] = $prevserverow[$i+3]

					}

				}

				#remove the Row from prev matrix

				$prevServerMatrix.Remove($_)

			}	

        }

        else

        {

            psDebugLog -level 1 -message "PREV MAtrix Empty"  

        }

    }

	

	psDebugLog -level 1 -message "AFTER COMPARE"

	psDebugLog -level 1 -message "Current MATRIX"

	$serverMatrix.Keys | % { "ST = $_ , OmsaOOBiSM = " + $serverMatrix.Item($_) }

	psDebugLog -level 1 -message "PREV MATRIX"

	$prevServerMatrix.Keys | % { "pST = $_ , OmsaOOBiSM = " + $prevServerMatrix.Item($_) }

	

	#Merge the matrices

	$serverMatrix = $serverMatrix + $prevServerMatrix

	

	psDebugLog -level 1 -message "AFTER MERGER"

	psDebugLog -level 1 -message "Current MATRIX"

	$serverMatrix.Keys | % { "ST = $_ , OmsaOOBiSM = " + $serverMatrix.Item($_) }

	psDebugLog -level 1 -message "PREV MATRIX"

	$prevServerMatrix.Keys | % { "pST = $_ , OmsaOOBiSM = " + $prevServerMatrix.Item($_) }

	

	psDebugLog -level 1 -message "Removing servers uninstalled service AFTER MERGER"

	$serverMatrix.Keys | ForEach-Object {

		psDebugLog -level 1 -message "Current hashtable is: "+($serverMatrix.Item($_))

		$serverow = $serverMatrix.Item($_) 



		for($i=0;$i -lt 3; $i++)

		{

			if($serverow[$i] -lt $NA)

			{

				#Check for OMSA, iSM installed

				$dellServiceExists = Confirm-WindowsServiceExists -srvType $i -serverId $serverow[$i+3]

				if($dellServiceExists)

				{

					psDebugLog -level 1 -message "Dell Service is available "

				}

				else

				{

					psDebugLog -level 1 -message "Dell Service is not available "

					$serverow[$i] = $NA

				}

			}

		}

	}

	

	$serverMatrix.Keys | ForEach-Object {

		$freePriorFlag = ($SetPreferredMonitoringMethod -eq $CONST_INBAND)

		$fallback = $SetUseLicenseFallbackForFreeMethod

		psDebugLog -level 1 -message "@@@@"

		psDebugLog -level 1 -message "Processing MatriX for $_"

		$serverow = $serverMatrix.Item($_)

		psDebugLog -level 1 -message $serverow

		if($freePriorFlag)

		{

			psDebugLog -level 1 -message "Free Priority "

			if($serverow[$enum_INBAND] -lt $NA)

			{

				psDebugLog -level 1 -message "INBAND available"

				$serverow[$enum_INBAND] = $truth

				if($serverow[$enum_OOB] -lt $NA)

				{

					psDebugLog -level 1 -message "TURNING OFF OOB" 

					$serverow[$enum_OOB] = $fallse

				}

				if($serverow[$enum_ISM] -lt $NA)

				{

					psDebugLog -level 1 -message "TURNING OFF ISM" 

					$serverow[$enum_ISM] = $fallse

				}

			}

			else

			{

				psDebugLog -level 1 -message "INBAND Not available"

				if($serverow[$enum_OOB] -lt $NA)

				{

					psDebugLog -level 1 -message "OOB available"

					$serverow[$enum_OOB] = $truth

					if($serverow[$enum_ISM] -lt $NA)

					{

						psDebugLog -level 1 -message "TURNING OFF ISM"

						$serverow[$enum_ISM] = $fallse

					}

				}

				else

				{

					psDebugLog -level 1 -message "OOB not available"

					if($serverow[$enum_ISM] -lt $NA)

					{

						psDebugLog -level 1 -message "ISM available"

						if($fallback -eq $true)

						{

							psDebugLog -level 1 -message "ISM available and Fallback TRUE hence turning ON ISM" 

							$serverow[$enum_ISM] = $truth

						}

						else

						{

							psDebugLog -level 1 -message "ISM available and Fallback FALSE hence turning OFF ISM" 

							$serverow[$enum_ISM] = $fallse

						}

					}

					else

					{

						psDebugLog -level 1 -message "ISM not available!!!!!!!"

					}

				}

			}

		}

		else

		{

			psDebugLog -level 1 -message "Licensed FLag ON"

			if($serverow[$enum_OOB] -lt $NA)

			{

				psDebugLog -level 1 -message "OOB available"

				$serverow[$enum_OOB] = $truth

				if($serverow[$enum_ISM] -lt $NA)

				{

					psDebugLog -level 1 -message "TURNING OFF ISM"

					$serverow[$enum_ISM] = $fallse

				}

				if($serverow[$enum_INBAND] -lt $NA)

				{

					psDebugLog -level 1 -message "TURNING OFF INBAND"

					$serverow[$enum_INBAND] = $fallse

				}

			}

			else

			{

				psDebugLog -level 1 -message "OOB not available"

				if($serverow[$enum_ISM] -lt $NA)

				{

					psDebugLog -level 1 -message "ISM available"

					$serverow[$enum_ISM] = $truth

					if($serverow[$enum_INBAND] -lt $NA)

					{

						#Generate critical Windows Event here as per BSPEC

						$omsaHost = $windowsServerInstances | where {$_.id -eq $serverow[$enum_INBAND + 3]}

						psDebugLog -level 1 -message ("Critical event generation host Name "+$omsaHost.Name)

						$message = "Uninstall/Stop OMSA services to monitor Dell Server on "+$omsaHost.Name

						$api = new-object -comObject 'MOM.ScriptAPI'

						$api.LogScriptEvent('SetPreferredMonitoringDSMT.ps1',1234,1,$message)

						psDebugLog -level 1 -message "TURNING OFF INBAND"

						$serverow[$enum_INBAND] = $fallse

					}

				}

				else

				{

					psDebugLog -level 1 -message "ISM NOT available"

					if($serverow[$enum_INBAND] -lt $NA)

					{

						psDebugLog -level 1 -message "INBAND available"

						$serverow[$enum_INBAND] = $truth

					}

				}

			}

		}

	}



	psDebugLog -level 1 -message "FINAL MATRIX b4 MP creation"

	$serverMatrix.Keys | % {"ST = $_ , OmsaOOBiSM = " + $serverMatrix.Item($_) }

	

	#create the override

  	$serverMatrix.Keys | ForEach-Object {

		psDebugLog -level 1 -message "Current Override creation is: $_"

		$serverow = $serverMatrix.Item($_) 

		#$serverow

		for($i=0;$i -lt 3; $i++)

		{

			if(($serverow[$i] -eq $truth) -or ($serverow[$i] -eq $fallse))

			{

				$value = ($serverow[$i] -eq $truth)

				

				$tag = $_.tostring()#else was appending a * :(

				#write-host "CREATING OVVERIDE ST "$tag

				$overrideDisplayName = ($overrideDisplayNames[$i] -f $tag)

				$override = (($overrideDisplayName.Replace(" ", [String]::Empty)) -replace '-', '_')

				$cxtInst = $serverow[$i+3]

				#write-host "CREATING OVVERIDE "$override" Cxt inxtance "$cxtInst

				CreateDiscoveryOverride -ovrdMP $ovrdMP -discovery $DiscoveryName[$i] -overridename $override -discoveryTgtClass $DiscoveryTgtSCOMClassName[$i] -overrideParameter $DiscoveryOverrideParameterName[$i] -overrideParameterValue $value.ToString().ToLower() -overrideModule $DiscoveryOverrideModule[$i] -contextInstance $cxtInst

			}

		}

	}

  

	$ovrdMP.Verify();

    psDebugLog -level 1 -message "Applying Changes"



    # save the changes into the override management pack

    Write-Info -msg "Accepting Changes"

    try {

        $ovrdMP.AcceptChanges()

        Write-Info -msg ("Management Pack Changes applied successfully")

    } catch [Exception] {

        Write-Info -msg ("Management Pack Changes could not be applied.  Exception Details given below")

        $_ | fl * -Force

        if ($LogLevel -ge 1)

        {

            $_ | fl * -Force | Out-File -FilePath $LogFileLocation

        }

    }



	$oAPI = new-object -comObject "MOM.ScriptAPI"

	$DiscoveryF = $oAPI.CreateDiscoveryData(0, $sourceID, $managedEntityID)

	$InstanceSP = $DiscoveryF.CreateClassInstance("$MPElement[Name='DellOperationsCommon!Dell.Discovery.Sink']$")

	$InstanceSP.AddProperty("$MPElement[Name='System!System.Entity']/DisplayName$", "Dell SPM Discovery Sink")

	$InstanceSP.AddProperty("$MPElement[Name='DellOperationsCommon!Dell.Discovery.Sink']/Name$", "Dell SPM Discovery Sink")

	$DiscoveryF.AddInstance($InstanceSP)

    # Return the discovery data by calling the variable

    $DiscoveryF

	

    psDebugLog -level 1 -message  ("End of " + $scriptname + " Discovery script ")

    psDebugLog -level 1 -message  "----------------------------------------------"





				</Script></ScriptBody>

          <Parameters>

            <Parameter>

              <Name>sourceID</Name>

              <Value>$MPElement$</Value>

            </Parameter>

            <Parameter>

              <Name>managedEntityID</Name>

              <Value>$Target/Id$</Value>

            </Parameter>

            <Parameter>

              <Name>IntervalSeconds</Name>

              <Value>$Config/IntervalSeconds$</Value>

            </Parameter>

            <Parameter>

              <Name>LogLevel</Name>

              <Value>$Config/LogLevel$</Value>

            </Parameter>

            <Parameter>

              <Name>SetPreferredMonitoringMethod</Name>

              <Value>$Config/SetPreferredMonitoringMethod$</Value>

            </Parameter>

            <Parameter>

              <Name>SetUseLicenseFallbackForFreeMethod</Name>

              <Value>$Config/SetUseLicenseFallbackForFreeMethod$</Value>

            </Parameter>

          </Parameters>

          <TimeoutSeconds>$Config/TimeoutSeconds$</TimeoutSeconds>

        </DataSource>

      </MemberModules>

      <Composition>

        <Node ID="SPM"/>

      </Composition>

    </Composite>

  </ModuleImplementation>

  <OutputType>System!System.Discovery.Data</OutputType>

</DataSourceModuleType>