Dell Server Set Preferred Monitoring DSMT

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

DSMT for Setting Preferred Monitoring 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"/>

  </Configuration>

  <OverrideableParameters>

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

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

  </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: Vaideeswaran Ganesan, Anirban Kundu                        #

    #  (c) Copyright Dell Inc. 2012-2015. All rights reserved                  #

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



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

    $CONST_INBAND = 'Inband'

    $CONST_OOB = 'OOB'



    $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 SCE2010 Module - for connection to SCE and SCE task functionality

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

    $sce2010Interface = new-module {

            [object]$connection = $null

            [string] $state = ''

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

            [int] $loglevel = 1

            [string] $product = "SCE 2010"



            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()

            {

                $this.connection = [Microsoft.EnterpriseManagement.ManagementGroup]::connect("localhost")

                $this.state = 'connected'

            }



            function LoadSnapins()

            {

                [System.Reflection.Assembly]::LoadFile("C:\Program Files\System Center Essentials\SDK Binaries\Microsoft.EnterpriseManagement.OperationsManager.Common.dll") &gt; $null

                [System.Reflection.Assembly]::LoadFile("C:\Program Files\System Center Essentials\SDK Binaries\Microsoft.EnterpriseManagement.OperationsManager.dll") &gt; $null

                $this.state = 'snapins loaded'

            }



            Function GetManagementPacks()

            {

               return $this.connection.GetManagementPacks()

            }



            function InstallManagementPack($ImportPath)

            {

               $v = $null

               try {

                    $this.connection.ImportManagementPack($ImportPath)

               } catch {

                  $v = $_

               }

               return $v

            }



            function UninstallManagementPack($ManagementPack)

            {

               $this.connection.UninstallManagementPack($ManagementPack)

               $v = $null

               return $v

            }



            function PrintDebug()

            {

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

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

            }



            function GetSCOMInstallDir()

            {

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

            }



            function GetManagementGroup()

            {

                return $this.connection

            }



        function IsSCE2010()

        {

            return $true

        }



        function IsSCOM2007R2()

        {

            return $false

        }



        function IsSCOM2012()

        {

            return $false

        }



            Export-ModuleMember -function * -variable *

    } -asCustomObject



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

# Creating new SCOM2007 R2 Module - for connection to 2007R2 and 2007R2 task functionality

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

    $scom2007r2Interface = new-module {

            [object]$connection = $null

            [string] $state = ''

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

            [int] $loglevel = 1

            [string] $product = "SCOM 2007 R2"



            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()

            {

                $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}'.";



                $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 = $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.

                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.

                    $error.Clear();

                    $this.connection = New-ManagementGroupConnection -ConnectionString:$server -ErrorAction:SilentlyContinue

                    psDebugLog -level 1 -message  ("After : " + $msg)

                    if ($this.connection -ne $null)

                    {

                        psDebugLog -level 1 -message  ("Connection Success! " + $this.connection)

                    }



                    # If the connection failed due to insufficient access then prompt for credentials.

                    if ($error.Count -gt 0 -and $error[0].Exception -is [Microsoft.EnterpriseManagement.Common.UnauthorizedAccessMonitoringException])

                    {

                        psDebugLog -level 1 -message   ("Failed to connect")

                        $error.Clear();

                    }



                    if ($error.Count -gt 0 -and $error[0].Exception -is [Microsoft.EnterpriseManagement.Common.UnauthorizedAccessMonitoringException])

                    {

                        $errMsg = $AccessDeniedErrorMsg -f $server;

                        psDebugLog -level 1 -message  $errMsg

                    }



                    if ($this.connection -eq $null)

                    {

                        $errMsg = $ConnectErrorMsg -f $server;

                        psDebugLog -level 1 -message  $errMsg

                    }

                }



                if ($this.connection -ne $null)

                {

                   psDebugLog -level 1 -message  ("Setting to path: " + "OperationsManagerMonitoring::")

                   Set-Location "OperationsManagerMonitoring::"

                   psDebugLog -level 1 -message  ("Current Directory: " + (pwd).Path)

                   psDebugLog -level 1 -message  ("Setting to path: " + $server)

                   Set-Location $server;

                   psDebugLog -level 1 -message  ("Current Directory: " + (pwd).Path)

                           }

                           $this.state = 'connected'

                           return $this.connection



                       }



            function LoadSnapins()

            {

                $snapin = (Get-PsSnapin Microsoft.EnterpriseManagement.OperationsManager.Client -ErrorVariable $snapinerr -ErrorAction:SilentlyContinue)

                if ($snapin -eq $null)

                {

                   Add-PsSnapin Microsoft.EnterpriseManagement.OperationsManager.Client -ErrorVariable $snapinerr -ErrorAction:SilentlyContinue

                   if ($snapinerr -eq $null -or $snapinerr.Count -eq 0) {

                       # successful!

                       psDebugLog -level 1 -message  "Snapin succeeded"

                   }

                   else

                   {

                       psDebugLog -level 1 -message  "Snapin Failed"

                      psDebugLog -level 1 -message  $snapinerr

                   }

                }

                $this.state = 'snapins loaded'

            }



            Function GetManagementPacks()

            {

               return (Get-ManagementPack)

            }



            function InstallManagementPack($ImportPath)

            {

                # $this.connection.ManagementGroup.ManagementPacks.ImportManagementPack($ImportPath)

               Install-ManagementPack -filepath $ImportPath -ErrorAction:SilentlyContinue -ErrorVariable v

               return $v

            }



            function UninstallManagementPack($ManagementPack)

            {

               Uninstall-ManagementPack -ManagementPack $ManagementPack -ErrorAction:SilentlyContinue -ErrorVariable v

               return $v

            }



            function PrintDebug()

            {

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

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

            }



            function GetSCOMInstallDir()

            {

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

            }



            function GetManagementGroup()

            {

                return $this.connection.ManagementGroup

            }



        function IsSCE2010()

        {

            return $false

        }



        function IsSCOM2007R2()

        {

            return $true

        }



        function IsSCOM2012()

        {

            return $false

        }





            Export-ModuleMember -function * -variable *

    } -asCustomObject



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

# 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 IsSCE2010()

        {

            return $false

        }



        function IsSCOM2007R2()

        {

            return $false

        }



        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, SCE2010 or SCOM2007R2)

    # based on presence detected on mgmtServer



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

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

    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;

    if ($skuName.SKU -eq "OEMMAX")

    {

       $scomenv = $sce2010Interface

    }

    elseif ( $skuVersion.CurrentVersion -match "^6.*" )

    {

       $scomenv = $scom2007r2Interface

    }

    else

    {

       $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"



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

    $oobOverrideName =    'OutOfBand-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

    $dellWindowsServerSvcTagHashMap = @{}

    $dellOOBServerSvcTagHashMap = @{}

    $bothInbandAndOOBDiscoveredServersMap = @{}





    $prev_dellWindowsServerSvcTagHashMap = @{}

    $prev_dellOOBServerSvcTagHashMap = @{}

    $prev_bothInbandAndOOBDiscoveredServersMap = @{}

    $prev_bothInbandAndOOBDiscoveredServersServiceTagMap = @{}



    $prevOverridesMap = @{}

    $prevOverrideContextMap = @{}

    $prevOverrideValueMap = @{}

    $prevOverrideTypeMap = @{}



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

    #  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)

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

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

        }

    }





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

    #  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 'ServiceTag' }

            $serverTag = $server.GetMonitoringPropertyValue($property_ServiceTag)

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



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

        }

    }





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

    #  GetServerObjectsMapDiscoveredByInbandAndOOB

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



    foreach ($serverServiceTag in $dellOOBServerSvcTagHashMap.Keys)

    {

       write-info -msg "checking "

       if ($dellWindowsServerSvcTagHashMap.Contains($serverServiceTag) -eq $true) {

           # Service tag is found for both Agent-based and Agent-free

           write-info -msg ($serverServiceTag + " is discovered by both inband and oob")

           $bothInbandAndOOBDiscoveredServersMap += @{ $serverServiceTag = "yes" }

       } else {

           write-info -msg ($serverServiceTag + " is discovered one method only")

       }

    }



    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'

    }



    # 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($_.ContextInstance) -eq $false)

            {

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

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

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

            }

            else

            {

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

            }

        }

        DeleteManagementPack -deleteMP $ovrdMP

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

    }



    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] }

            $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] }

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

            $ovrdMP.References.Remove($mpref)

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

        }

    }





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

    # Overrides Creation

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





    function SanitizeOverrideName

    {

       param($ovrName)

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

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

       return $inbandmatchOvrName

    }



    function CreateOOBOverride

    {

        param($DoDiscovery, $server, $serverClass, $tag, $usePreviousOverrideIfPresent)

        write-info -msg ("Overriding server=" + $server.DisplayName)

        $oobDeviceForServer = $null

        $server.GetMonitoringRelationshipObjects() | foreach -process {

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

            {

                $oobDeviceForServer = $_.TargetMonitoringObject

            }

        }



        $overrideDisplayName = ($oobOverrideName -f $tag)

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

        $overridevalue = $DoDiscovery



        if ($prevOverridesMap.ContainsKey($oobDeviceForServer.Id) -eq $true)

        {

             if ($usePreviousOverrideIfPresent -eq $true)

             {

                  $overridevalue = $prevOverrideValueMap[$oobDeviceForServer.Id]

             }

             $prevOverridesMap.Remove($oobDeviceForServer.Id)

             $prevOverrideContextMap.Remove($oobDeviceForServer.Id)

             $prevOverrideValueMap.Remove($oobDeviceForServer.Id)

             $prevOverrideTypeMap.Remove($oobDeviceForServer.Id)

        }

        $ovrvalue = $overridevalue.ToString().ToLower()



        write-info -msg ("====== Create OOB Override ==================")

        write-info -msg ("Override=$override")

        write-info -msg ("Discovery=$twoDiscoveryName")

        write-info -msg ("Context=" + $serverClass.Name)

        write-info -msg ("ContextInstance=" + $oobDeviceForServer.Id)

        write-info -msg ("OverideValue=$ovrvalue")

        CreateDiscoveryOverride -ovrdMP $ovrdMP -discovery $twoDiscoveryName -overridename $override -discoveryTgtClass $smashServerClass -overrideParameter $twoDiscoveryOverrideParameterName -overrideParameterValue $ovrvalue -overrideModule $twoDiscoveryOverrideModule -contextInstance $oobDeviceForServer.Id

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

    }





    function CreateInbandOverride

    {

        param($DoDiscovery, $server, $serverClass, $tag, $usePreviousOverrideIfPresent)

        write-info -msg ("Overriding server=" + $server.DisplayName)

        $windowsDeviceForServer = $null

        $server.GetMonitoringRelationshipObjects() | foreach -process {

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

            {

                $windowsDeviceForServer = $_.SourceMonitoringObject

            }

        }

        $overrideDisplayName = ($inbandOverrideName -f $tag)

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

        $overridevalue = $DoDiscovery

        if ($prevOverridesMap.ContainsKey($windowsDeviceForServer.Id) -eq $true)

        {

             if ($usePreviousOverrideIfPresent -eq $true)

             {

                  $overridevalue = $prevOverrideValueMap[$windowsDeviceForServer.Id]

             }

             $prevOverridesMap.Remove($windowsDeviceForServer.Id)

             $prevOverrideContextMap.Remove($windowsDeviceForServer.Id)

             $prevOverrideValueMap.Remove($windowsDeviceForServer.Id)

             $prevOverrideTypeMap.Remove($windowsDeviceForServer.Id)

        }

        $ovrvalue = $overridevalue.ToString().ToLower()

        write-info -msg ("====== Create Inband Override ==================")

        write-info -msg ("Override=$override")

        write-info -msg ("Discovery=$oneDiscoveryName")

        write-info -msg ("Context=" + $serverClass.Name)

        write-info -msg ("ContextInstance=" + $windowsDeviceForServer.Id)

        write-info -msg ("OverideValue=$ovrvalue")

        CreateDiscoveryOverride -ovrdMP $ovrdMP -discovery $oneDiscoveryName -overridename $override -discoveryTgtClass $windowsServerClass -overrideParameter $oneDiscoveryOverrideParameterName -overrideParameterValue $ovrvalue -overrideModule $oneDiscoveryOverrideModule -contextInstance $windowsDeviceForServer.Id

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

    }



    $overrideMPDoesNotExist = $false



    if ($overrideMPDoesNotExist -eq $true)

    {

        foreach ($inbandServerServiceTag in $dellWindowsServerSvcTagHashMap.Keys)

        {

            if ($bothInbandAndOOBDiscoveredServersMap.ContainsKey($inbandServerServiceTag) -eq $true) { continue }

            CreateInbandOverride -DoDiscovery $true -server $dellWindowsServerSvcTagHashMap[$inbandServerServiceTag] -serverClass $windowsServerClass -tag $inbandServerServiceTag -usePreviousOverrideIfPresent $true

        }



        foreach ($oobServerServiceTag in $dellOOBServerSvcTagHashMap.Keys)

        {

            if ($bothInbandAndOOBDiscoveredServersMap.ContainsKey($oobServerServiceTag) -eq $true) { continue }

            CreateOOBOverride -DoDiscovery $true -server $dellOOBServerSvcTagHashMap[$oobServerServiceTag]  -serverClass $smashServerClass -tag $oobServerServiceTag  -usePreviousOverrideIfPresent $true

        }



        $inbandoverride = ($SetPreferredMonitoringMethod -eq $CONST_INBAND)

        $ooboverride    = ($SetPreferredMonitoringMethod -ne $CONST_INBAND)

        foreach ($serverServiceTag in $bothInbandAndOOBDiscoveredServersMap.Keys)

        {

            CreateInbandOverride -DoDiscovery $inbandoverride -server $dellWindowsServerSvcTagHashMap[$serverServiceTag]  -serverClass $windowsServerClass  -tag $inbandServerServiceTag  -usePreviousOverrideIfPresent $false

            CreateOOBOverride -DoDiscovery $ooboverride    -server $dellOOBServerSvcTagHashMap[$serverServiceTag] -serverClass $smashServerClass -tag $oobServerServiceTag  -usePreviousOverrideIfPresent $false

        }

    }

    else

    {

        foreach ($ovr in $prevOverridesMap.Keys)

        {

            $ovrName = $prevOverridesMap[$ovr]

    

            $inbandmatchOvrName = SanitizeOverrideName -ovrName $inbandOverrideName

            $oobmatchOvrName = SanitizeOverrideName -ovrName $oobOverrideName



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

            {

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

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

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



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

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

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

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

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

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

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

            }

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

            {

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

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

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

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

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

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

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

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

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

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

            }

        }

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

        foreach ($serverServiceTag in $prev_dellOOBServerSvcTagHashMap.Keys)

        {

           if ($prev_dellWindowsServerSvcTagHashMap.Contains($serverServiceTag) -eq $true) {

               # Service tag is found for both Agent-based and Agent-free

               write-info -msg ($serverServiceTag + " is discovered by both inband and oob")

               $prev_bothInbandAndOOBDiscoveredServersMap += @{ $prev_dellOOBServerSvcTagHashMap[$serverServiceTag] = $serverServiceTag }

               $prev_bothInbandAndOOBDiscoveredServersMap += @{ $prev_dellWindowsServerSvcTagHashMap[$serverServiceTag] = $serverServiceTag }

               $prev_bothInbandAndOOBDiscoveredServersServiceTagMap += @{ $serverServiceTag = "yes" }

           } else {

               write-info -msg ($serverServiceTag + " is discovered one method only")

           }

        }

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



        # Use Case 1: SMASH or Windows Computer object was removed since last run

        foreach ($ovr in $prevOverridesMap.Keys)

        {

            if ($idList.ContainsKey($ovr) -eq $true)

            { 

                write-info -msg ($ovr.ToString() + "(" + $prevOverridesMap[$ovr] + ") is ok")

                continue

            }

            if ($prev_bothInbandAndOOBDiscoveredServersMap.ContainsKey($ovr) -eq $true)

            { 

                write-info -msg ("Flip the other override " + $prevOverridesMap[$ovr])

                $serviceTag = $prev_bothInbandAndOOBDiscoveredServersMap[$ovr]

                if ($prevOverrideTypeMap[$ovr] -eq $CONST_INBAND)

                {

                     $alternateMethod = $prev_dellOOBServerSvcTagHashMap[$serviceTag]

                }

                else

                {

                     $alternateMethod = $prev_dellWindowsServerSvcTagHashMap[$serviceTag]

                }

                $prevOverrideValueMap[$alternateMethod] = $true

            }

            write-info -msg ("Remove " + $prevOverridesMap[$ovr])

            $prevOverridesMap.Remove($ovr)

            $prevOverrideContextMap.Remove($ovr)

            $prevOverrideValueMap.Remove($ovr)

            $prevOverrideTypeMap.Remove($ovr)

            $prev_bothInbandAndOOBDiscoveredServersMap.Remove($ovr)

            $prev_bothInbandAndOOBDiscoveredServersServiceTagMap.Remove($serverServiceTag)

        }



        # Use Case 2: Failure Scenarios

        write-info -msg ("UC2: Failure Scenarios")

        foreach ($serverServiceTag in $prev_bothInbandAndOOBDiscoveredServersServiceTagMap.Keys)

        {

            write-info -msg ("UC2: Analyzing " + $serverServiceTag)

            $inbandoverride = ($SetPreferredMonitoringMethod -eq $CONST_INBAND)

            $ooboverride    = ($SetPreferredMonitoringMethod -ne $CONST_INBAND)

            $oobMethodStatus = $prevOverrideValueMap[$prev_dellOOBServerSvcTagHashMap[$serverServiceTag]]

            $inbandMethodStatus = $prevOverrideValueMap[$prev_dellWindowsServerSvcTagHashMap[$serverServiceTag]]



            if ($oobMethodStatus -ne $inbandMethodStatus)

            {

                write-info -msg ("UC2: " + $serverServiceTag + " has overriden to be discovered by one method")

                # this means only one method is currenty in vogue.  We need to ensure that it reflects the SPM status.

                # if the no server object is physically pesent, flip both to true.

                if (($inbandMethodStatus -eq $true -and $dellWindowsServerSvcTagHashMap.ContainsKey($serverServiceTag) -eq $false) -or

                     ($oobMethodStatus -eq $true -and $dellOOBServerSvcTagHashMap.ContainsKey($serverServiceTag) -eq $false))

                {

                    write-info -msg ("UC2: " + $serverServiceTag + " override is enabled for alternate method")

                    $prevOverrideValueMap[$prev_dellOOBServerSvcTagHashMap[$serverServiceTag]] = $true

                    $prevOverrideValueMap[$prev_dellWindowsServerSvcTagHashMap[$serverServiceTag]] = $true

                }

            }

        }

        write-info -msg ("UC2: Done")



        write-info -msg ("UC3: Switch Preferred Method")

        # Use Case 3: Switch to PreferredMethod

        foreach ($serverServiceTag in $prev_bothInbandAndOOBDiscoveredServersServiceTagMap.Keys)

        {

            write-info -msg ("UC3: Analyzing " + $serverServiceTag)

            $inbandoverride = ($SetPreferredMonitoringMethod -eq $CONST_INBAND)

            $ooboverride    = ($SetPreferredMonitoringMethod -ne $CONST_INBAND)

            $oobMethodStatus = $prevOverrideValueMap[$prev_dellOOBServerSvcTagHashMap[$serverServiceTag]]

            $inbandMethodStatus = $prevOverrideValueMap[$prev_dellWindowsServerSvcTagHashMap[$serverServiceTag]]

            if ($oobMethodStatus -ne $inbandMethodStatus)

            {

                write-info -msg ("UC3: " + $serverServiceTag + " override is flipped")

                # this means only one method is currenty in vogue.  We need to ensure that it reflects the SPM status.

                $prevOverrideValueMap[$prev_dellOOBServerSvcTagHashMap[$serverServiceTag]]     = $ooboverride

                $prevOverrideValueMap[$prev_dellWindowsServerSvcTagHashMap[$serverServiceTag]] = $inbandoverride

            }

        }

        write-info -msg ("UC3: Done")



        # Use Case 4 : Reconcile newly added servers with the above

        write-info -msg ("UC4: Newly Added Servers")

        write-info -msg ("UC4: P1: Inband Servers")

        foreach ($inbandServerServiceTag in $dellWindowsServerSvcTagHashMap.Keys)

        {

            if ($bothInbandAndOOBDiscoveredServersMap.ContainsKey($inbandServerServiceTag) -eq $true) { continue }

            write-info -msg ("UC4: P1: Creating Override for inband discovery: " + $inbandServerServiceTag)

            CreateInbandOverride -DoDiscovery $true -server $dellWindowsServerSvcTagHashMap[$inbandServerServiceTag] -serverClass $windowsServerClass -tag $inbandServerServiceTag  -usePreviousOverrideIfPresent $true

        }

        write-info -msg ("UC4: P1: Inband Servers Done")



        write-info -msg ("UC4: P2: OOB Servers")

        foreach ($oobServerServiceTag in $dellOOBServerSvcTagHashMap.Keys)

        {

            if ($bothInbandAndOOBDiscoveredServersMap.ContainsKey($oobServerServiceTag) -eq $true) { continue }

            write-info -msg ("UC4: P2: Creating Override for OOB discovery: " + $oobServerServiceTag)

            CreateOOBOverride -DoDiscovery $true -server $dellOOBServerSvcTagHashMap[$oobServerServiceTag]  -serverClass $smashServerClass -tag $oobServerServiceTag  -usePreviousOverrideIfPresent $true

        }

        write-info -msg ("UC4: P2: OOB Servers Done")



        write-info -msg ("UC4: P3: Common Servers")

        $inbandoverride = ($SetPreferredMonitoringMethod -eq $CONST_INBAND)

        $ooboverride    = ($SetPreferredMonitoringMethod -ne $CONST_INBAND)

        foreach ($serverServiceTag in $bothInbandAndOOBDiscoveredServersMap.Keys)

        {

            write-info -msg ("UC4: P3: Creating Override for preferred method: " + $serverServiceTag)

            CreateInbandOverride -DoDiscovery $inbandoverride -server $dellWindowsServerSvcTagHashMap[$serverServiceTag]  -serverClass $windowsServerClass  -tag $serverServiceTag  -usePreviousOverrideIfPresent $false

            CreateOOBOverride    -DoDiscovery $ooboverride    -server $dellOOBServerSvcTagHashMap[$serverServiceTag]      -serverClass $smashServerClass    -tag $serverServiceTag  -usePreviousOverrideIfPresent $false

        }

        write-info -msg ("UC4: P3: OOB Servers Done")



        write-info -msg ("UC4: P4: Original Overrides")

        # Finally Write the previous overrides to the MP

        foreach ($ovr in $prevOverridesMap.Keys)

        {

            $ovrName = $prevOverridesMap[$ovr]

            write-info -msg ("UC4: P4: Applying Original Overrides for " + $ovrName)

            if ( $prevOverrideTypeMap[$ovr] -eq $CONST_INBAND )

            {

                write-info -msg ("====== Create Inband Override ==================")

                write-info -msg ("Override="+$prevOverridesMap[$ovr])

                write-info -msg ("Discovery=$oneDiscoveryName")

                write-info -msg ("Context=" + $windowsServerClass.Name)

                write-info -msg ("ContextInstance=" + $ovr)

                write-info -msg ("OverideValue="+$prevOverrideValueMap[$ovr].ToString().ToLower())

                CreateDiscoveryOverride -ovrdMP $ovrdMP -discovery $oneDiscoveryName -overridename $prevOverridesMap[$ovr] -discoveryTgtClass $windowsServerClass -overrideParameter $oneDiscoveryOverrideParameterName -overrideParameterValue $prevOverrideValueMap[$ovr].ToString().ToLower() -overrideModule $oneDiscoveryOverrideModule -contextInstance $ovr

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

            }

            else

            {

                write-info -msg ("====== Create OOB Override ==================")

                write-info -msg ("Override="+$prevOverridesMap[$ovr])

                write-info -msg ("Discovery=$twoDiscoveryName")

                write-info -msg ("Context=" + $smashServerClass.Name)

                write-info -msg ("ContextInstance=" + $ovr)

                write-info -msg ("OverideValue="+$prevOverrideValueMap[$ovr].ToString().ToLower())

                CreateDiscoveryOverride -ovrdMP $ovrdMP -discovery $twoDiscoveryName -overridename $prevOverridesMap[$ovr] -discoveryTgtClass $smashServerClass -overrideParameter $twoDiscoveryOverrideParameterName -overrideParameterValue $prevOverrideValueMap[$ovr].ToString().ToLower() -overrideModule $oneDiscoveryOverrideModule -contextInstance $ovr

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

            }

        }

        write-info -msg ("UC4: P4: Original Overrides Done")

        write-info -msg ("UC4: Done")

    }





    # verify the changes in the override management pack

    $ovrdMP.Verify();

    Write-Info -msg "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>

          </Parameters>

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

        </DataSource>

      </MemberModules>

      <Composition>

        <Node ID="SPM"/>

      </Composition>

    </Composite>

  </ModuleImplementation>

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

</DataSourceModuleType>