A Collection of functions for creating an Operations Manager MP programatically

ManagementPack.psm1

Function New-ManagementPack
{
    [CmdletBinding()]
    Param
    (
    [string]$ID = 'ptech.LegatoNetworker',
    [string]$Version = '1.0.0.57',
    [string]$Name = 'Legato Networker MP'
    )
    Begin
    {
        $ManagementPack = New-XmlDocument -Root ManagementPack -Elements 'Manifest','TypeDefinitions','Monitoring','Presentation','LanguagePacks'
        Set-XmlAttribute -xDoc $ManagementPack -Node ManagementPack -Attribute ContentReadable -Value True
        Set-XmlAttribute -xDoc $ManagementPack -Node ManagementPack -Attribute 'xmlns:xsd' -Value 'http://www.w3.org/2001/XMLSchema'
        $xIdentity = New-XmlElement -xDoc $ManagementPack -Name Identity -ChildNodes 'ID','Version'
        $xName = New-XmlElement -xDoc $ManagementPack -Name Name
        $xReferences = New-XmlElement -xDoc $ManagementPack -Name References
        $xEntityTypes = New-XmlElement -xDoc $ManagementPack -Name EntityTypes -ChildNodes ClassTypes
        $xDiscoveries = New-XmlElement -xDoc $ManagementPack -Name Discoveries
        $xRules = New-XmlElement -xDoc $ManagementPack -Name Rules
        $ManagementPack = Add-XmlElement -xDoc $ManagementPack -Node Manifest -Element $xIdentity, $xName, $xReferences
        $ManagementPack = Add-XmlElement -xDoc $ManagementPack -Node TypeDefinitions -Element $xEntityTypes
        $ManagementPack = Add-XmlElement -xDoc $ManagementPack -Node Monitoring -Element $xDiscoveries, $xRules
        }
    Process
    {

        $ManagementPack.ManagementPack.Manifest.Identity.ID = $ID
        $ManagementPack.ManagementPack.Manifest.Identity.Version = $Version
        $ManagementPack.ManagementPack.Manifest.Name = $Name
        }
    End
    {
        return $ManagementPack
        }
    }
Function New-Reference
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [string]$Alias,
    [string]$ID,
    [string]$Version,
    [string]$PublicKeyToken
    )
    Begin
    {
        $Reference = New-XmlElement -xDoc $ManagementPack -Name Reference -ChildNodes ID,Version,PublicKeyToken -Property Alias -Value $Alias
        $Reference.ID = $ID
        $Reference.Version = $Version
        $Reference.PublicKeyToken = $PublicKeyToken
        }
    Process
    {
        }
    End
    {
        return $Reference
        }
    }
Function Add-Reference
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [System.Xml.XmlElement[]]$Reference
    )
    Begin
    {
        }
    Process
    {
        foreach ($Ref in $Reference)
        {
            Write-Verbose $Ref.OuterXml
            $ManagementPack = Add-XmlElement -xDoc $ManagementPack -Node References -Element $Ref
            }            
        }
    End
    {
        }
    }
Function New-ClassType
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [string]$ID,
    [string]$Base,
    [string]$Accessibility,
    [bool]$Abstract = $false,
    [bool]$Hosted = $false,
    [bool]$Singleton = $false,
    [string]$Comment
    )
    Begin
    {
        }
    Process
    {
        $ClassType = New-XmlElement -xDoc $ManagementPack -Name ClassType
        $ClassType.SetAttribute('ID',$ID)
        $ClassType.SetAttribute('Base',$Base)
        $ClassType.SetAttribute('Accessibility',$Accessibility)
        $ClassType.SetAttribute('Abstract',$Abstract.ToString())
        $ClassType.SetAttribute('Hosted',$Hosted.ToString())
        $ClassType.SetAttribute('Singleton',$Singleton.ToString())
        $ClassType.SetAttribute('Comment',$Comment)
        }
    End
    {
        return $ClassType
        }
    }
Function Add-ClassType
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [System.Xml.XmlElement[]]$ClassType
    )
    Begin
    {
        }
    Process
    {
        foreach ($Class in $ClassType)
        {
            Write-Verbose $Class.OuterXml
            $ManagementPack = Add-XmlElement -xDoc $ManagementPack -Node ClassTypes -Element $Class
            }            
        }
    End
    {
        }
    }
Function New-Property
{
    [CmdletBinding()]
    Param
    (
    [Parameter(Mandatory=$true,ParameterSetName='ClassType')]
    [Parameter(Mandatory=$true,ParameterSetName='DiscoveryClass')]
    [System.Xml.XmlDocument]$ManagementPack,
    [Parameter(Mandatory=$true,ParameterSetName='ClassType')]
    [switch]$ClassType,
    [Parameter(Mandatory=$true,ParameterSetName='ClassType')]
    [string]$ID,
    [Parameter(Mandatory=$true,ParameterSetName='ClassType')]
    [string]$Key,
    [Parameter(Mandatory=$true,ParameterSetName='ClassType')]
    [string]$Type,
    [Parameter(Mandatory=$true,ParameterSetName='DiscoveryClass')]
    [switch]$DiscoveryClass,
    [Parameter(Mandatory=$true,ParameterSetName='DiscoveryClass')]
    [string]$TypeID,
    [Parameter(Mandatory=$true,ParameterSetName='DiscoveryClass')]
    [string]$PropertyID
    )
    Begin
    {
        $Property = New-XmlElement -xDoc $ManagementPack -Name Property
        }
    Process
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'ClassType'
            {
                $Property.SetAttribute('ID',$ID)
                $Property.SetAttribute('Key',$Key)
                $Property.SetAttribute('Type',$Type)
                }
            'DiscoveryClass'
            {
                $Property.SetAttribute('TypeID',$TypeID)
                $Property.SetAttribute('PropertyID',$PropertyID)
                }
            }
        }
    End
    {
        return $Property
        }
    }
Function Add-Property
{
    [CmdletBinding()]
    Param
    (
    [Parameter(Mandatory=$true,ParameterSetName='ClassType')]
    [Parameter(Mandatory=$true,ParameterSetName='DiscoveryClass')]
    [System.Xml.XmlDocument]$ManagementPack,
    [Parameter(Mandatory=$true,ParameterSetName='ClassType')]
    [Parameter(Mandatory=$true,ParameterSetName='DiscoveryClass')]
    [System.Xml.XmlElement[]]$Property,
    [Parameter(Mandatory=$true,ParameterSetName='ClassType')]
    [switch]$ClassType,
    [Parameter(Mandatory=$true,ParameterSetName='DiscoveryClass')]
    [switch]$DiscoveryClass
    )
    Begin
    {
        }
    Process
    {
        foreach ($P in $Property)
        {
            Write-Verbose $P.OuterXml
            $ManagementPack = Add-XmlElement -xDoc $ManagementPack -Node $PSCmdlet.ParameterSetName -Element $P
            }            
        }
    End
    {
        }
    }
Function New-Discovery
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [string]$ID,
    [string]$Target,
    [bool]$Enabled,
    [bool]$ConfirmDelivery,
    [bool]$Remotable,
    [string]$Priority,
    [string]$Comment
    )
    Begin
    {
        }
    Process
    {
        $Discovery = New-XmlElement -xDoc $ManagementPack -Name Discovery -ChildNodes Category, DiscoveryTypes
        $Discovery.SetAttribute('ID',$ID)
        $Discovery.SetAttribute('Target',$Target)
        $Discovery.SetAttribute('Enabled',$Enabled)
        $Discovery.SetAttribute('ConfirmDelivery',$ConfirmDelivery)
        $Discovery.SetAttribute('Remotable',$Remotable)
        $Discovery.SetAttribute('Priority',$Priority)
        $Discovery.SetAttribute('Comment',$Comment)
        $Discovery.Category = 'Discovery'
        }
    End
    {
        return $Discovery
        }
    }
Function Add-Discovery
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [System.Xml.XmlElement[]]$Discovery
    )
    Begin
    {
        foreach ($D in $Discovery)
        {
            Write-Verbose $Discovery.OuterXml
            $ManagementPack = Add-XmlElement -xDoc $ManagementPack -Node Discoveries -Element $D
            }
        }
    Process
    {
        }
    End
    {
        }
    }
Function New-DiscoveryClass
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [string]$TypeID
    )
    Begin
    {
        }
    Process
    {
        $DiscoveryClass = New-XmlElement -xDoc $ManagementPack -Name DiscoveryClass -Property TypeID -Value $TypeID
        }
    End
    {
        return $DiscoveryClass
        }
    }
Function Add-DiscoveryClass
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [System.Xml.XmlElement[]]$DiscoveryClass
    )
    Begin
    {
        }
    Process
    {
        foreach ($DC in $DiscoveryClass)
        {
            Write-Verbose $DC.OuterXml
            $ManagementPack = Add-XmlElement -xDoc $ManagementPack -Node DiscoveryTypes -Element $DC
            }
        }
    End
    {
        }
    }
Function New-RegistryDataSource
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [string]$ID,
    [string]$TypeID,
    [string]$Comment,
    [string]$ComputerName,
    [string]$Frequency,
    [string]$ClassID
    )
    Begin
    {
        $DataSource = New-XmlElement -xDoc $ManagementPack -Name DataSource -ChildNodes ComputerName, RegistryAttributeDefinitions, Frequency, ClassID, InstanceSettings
        $DataSource.SetAttribute('ID',$ID)
        $DataSource.SetAttribute('TypeID',$TypeID)
        $DataSource.SetAttribute('Comment',$Comment)
        $DataSource.ComputerName = $ComputerName
        $DataSource.Frequency = $Frequency
        $DataSource.ClassID = $ClassID
        }
    Process
    {
        }
    End
    {
        return $DataSource
        }
    }
Function New-RegistryAttributeDefinition
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [string]$AttributeName,
    [string]$Path,
    [string]$PathType,
    [string]$AttributeType
    )
    Begin
    {
        }
    Process
    {
        $RegistryAttributeDefinition = New-XmlElement -xDoc $ManagementPack -Name RegistryAttributeDefinition -ChildNodes AttributeName, Path, PathType, AttributeType
        $RegistryAttributeDefinition.AttributeName = $AttributeName
        $RegistryAttributeDefinition.Path = $Path
        $RegistryAttributeDefinition.PathType = $PathType
        $RegistryAttributeDefinition.AttributeType = $AttributeType
        }
    End
    {
        Return $RegistryAttributeDefinition
        }
    }
Function Add-RegistryAttributeDefinition
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [System.Xml.XmlElement[]]$RegistryAttributeDefinition
    )
    Begin
    {
        }
    Process
    {
        foreach ($R in $RegistryAttributeDefinition)
        {
            Write-Verbose $R.OuterXml
            $ManagementPack = Add-XmlElement -xDoc $ManagementPack -Node RegistryAttributeDefinitions -Element $R
            }
        }
    End
    {
        }
    }
Function Add-DataSource
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [System.Xml.XmlElement[]]$DataSource
    )
    Begin
    {
        }
    Process
    {
        foreach ($DS in $DataSource)
        {
            Write-Verbose $DS.OuterXml
            $ManagementPack = Add-XmlElement -xDoc $ManagementPack -Node Discovery -Element $DS
            }
        }
    End
    {
        }
    }
Function New-InstanceSetting
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [string]$Name,
    [string]$Value
    )
    Begin
    {
        }
    Process
    {
        $InstanceSetting = New-XmlElement -xDoc $ManagementPack -Name InstanceSetting -ChildNodes Name, Value
        $InstanceSetting.Name = $Name
        $InstanceSetting.Value = $Value
        }
    End
    {
        return $InstanceSetting
        }
    }
Function Add-InstanceSetting
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [System.Xml.XmlElement[]]$InstanceSetting
    )
    Begin
    {
        }
    Process
    {
        foreach ($I in $InstanceSetting)
        {
            Write-Verbose $I.OuterXml
            $ManagementPack = Add-XmlElement -xDoc $ManagementPack -Node InstanceSettings -Element $I
            }
        }
    End
    {
        }
    }
Function New-DiscoveryRelationship
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [string]$TypeID
    )
    Begin
    {
        }
    Process
    {
        $DiscoveryRelationship = New-XmlElement -xDoc $ManagementPack -Name DiscoveryRelationship -Property TypeID -Value $TypeID
        }
    End
    {
        return $DiscoveryRelationship
        }
    }
Function Add-DiscoveryRelationship
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [System.Xml.XmlElement[]]$DiscoveryRelationship
    )
    Begin
    {
        }
    Process
    {
        foreach ($D in $DiscoveryRelationship)
        {
            Write-Verbose $D.OuterXml
            #
            # There are multiple DiscoveryTypes (one per discovery) need to find the right one on subsquent runs
            #
            $ManagementPack = Add-XmlElement -xDoc $ManagementPack -Node DiscoveryTypes -Element $D
            }
        }
    End
    {
        }
    }
Function New-GroupDataSource
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [string]$ID,
    [string]$TypeID,
    [string]$Comment,
    [string]$RuleID,
    [string]$GroupInstanceId,
    [string]$ClassID
    )
    Begin
    {
        $DataSource = New-XmlElement -xDoc $ManagementPack -Name DataSource -ChildNodes RuleID, GroupInstanceId, MembershipRules
        $DataSource.SetAttribute('ID',$ID)
        $DataSource.SetAttribute('TypeID',$TypeID)
        $DataSource.SetAttribute('Comment',$Comment)
        $DataSource.RuleID = $RuleID
        $DataSource.GroupInstanceId = $GroupInstanceId
        }
    Process
    {
        }
    End
    {
        return $DataSource
        }
    }
Function New-MembershipRule
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [string]$MonitoringClass,
    [string]$RelationshipClass
    )
    Begin
    {
        $MembershipRule = New-XmlElement -xDoc $ManagementPack -Name MembershipRule -ChildNodes MonitoringClass, RelationshipClass, Expression
        $MembershipRule.MonitoringClass = $MonitoringClass
        $MembershipRule.RelationshipClass = $RelationshipClass
        }
    Process
    {
        }
    End
    {
        Return $MembershipRule
        }
    }
Function Add-MembershipRule
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [System.Xml.XmlElement[]]$MembershipRule
    )
    Begin
    {
        }
    Process
    {
        foreach ($M in $MembershipRule)
        {
            Write-Verbose $M.OuterXml
            $ManagementPack = Add-XmlElement -xDoc $ManagementPack -Node MembershipRules -Element $M
            }
        }
    End
    {
        }
    }
Function New-Expression
{
    [CmdletBinding()]
    Param
    (
    [Parameter(Mandatory=$true, ParameterSetName='RegExExpression')]
    [System.Xml.XmlDocument]$ManagementPack,
    [Parameter(Mandatory=$true, ParameterSetName='RegExExpression')]
    [switch]$RegExExpression,
    [Parameter(Mandatory=$true, ParameterSetName='RegExExpression')]
    [string]$ValueExpression,
    [Parameter(Mandatory=$true, ParameterSetName='RegExExpression')]
    [string]$Operator,
    [Parameter(Mandatory=$true, ParameterSetName='RegExExpression')]
    [string]$Pattern
    )
    Begin
    {
        }
    Process
    {
        switch ($PSCmdlet.ParameterSetName)
        {
            'RegExExpression'
            {
                $Expression = New-XmlElement -xDoc $ManagementPack -Name 'RegExExpression' -ChildNodes Operator, Pattern
                $xValueExpression = New-XmlElement -xDoc $ManagementPack -Name ValueExpression -ChildNodes Property
                $Expression.Operator = $Operator
                $Expression.Pattern = $Pattern
                $Result = $Expression.InsertBefore($xValueExpression,$Expression.SelectSingleNode('Operator'))
                $Expression.ValueExpression.Property = $ValueExpression
                }
            }
        }
    End
    {
        Return $Expression
        }
    }
Function Add-Expression
{
    [CmdletBinding()]
    Param
    (
    [System.Xml.XmlDocument]$ManagementPack,
    [System.Xml.XmlElement[]]$Expression
    )
    Begin
    {
        }
    Process
    {
        foreach ($E in $Expression)
        {
            Write-Verbose $E.OuterXml
            $ManagementPack = Add-XmlElement -xDoc $ManagementPack -Node Expression -Element $E
            }
        }
    End
    {
        }
    }