Marcin@Work

Injecting CDATA into MPs

2013-01-30T00:36:00Z

There are situations where it may be useful to have the scripts that are part of your MP to be enclosed in CDATA tags. This allows you to copy and paste scripts directly from MP XML into a file and run them (usually to debug some issue).

If you use the $IncludeFileContent…$ directive in VSAE to include a text file into your MP in VSAE, your script will be wrapped in CDATA tags. If you do this, there’s no need to read the rest of this article. :)

However, if you do not use that directive, your script will not be enclosed in CDATA tags. This means that various characters such as < and > will be escaped to produce valid XML (< will be replaced with <, for example). While the MP will work correctly (both XML formats are equivalent), it makes it difficult to copy and paste the script into a file and run it.

The VSAE import wizard does not extract scripts from MPs, so these will end up inline with the XML and likely without CDATA tags. If you want to force CDATA tags back in, I came up with a quick workaround that adds an extra build step before MP verification in VSA to inject CDATA for specific locations in the MP.

To enable this functionality, please copy and paste the following text (until the closing Project tag) into a file called ManagementPack.CData.targets:

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<UsingTask
    TaskName="InjectCData"
    TaskFactory="CodeTaskFactory"
    AssemblyName="Microsoft.Build.Tasks.v4.0, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" >
    <ParameterGroup>
      <Input Required="true" ParameterType="System.String"/>
      <Output Required="true" ParameterType="System.String"/>
      <Paths Required="true" ParameterType="Microsoft.Build.Framework.ITaskItem[]"/>
    </ParameterGroup>
    <Task>
      <Reference Include="System.Xml" />
      <Reference Include="System.Xml.Linq" />
      <Using Namespace="System.Collections.Generic" />
      <Using Namespace="System.IO" />
      <Using Namespace="System.Linq" />
      <Using Namespace="System.Xml.Linq" />
      <Using Namespace="System.Xml.XPath" />
      <Code Type="Fragment" Language="cs">
<![CDATA[
            XDocument document = XDocument.Load(this.Input);
            IList<XElement> elements = this.Paths
                .Select(item => item.ItemSpec)
                .SelectMany(document.XPathSelectElements)
                .Where(element => element.HasElements == false)
                .ToList();
            foreach (XElement element in elements)
            {
                string contents = element.Value;
                element.SetValue(string.Empty);
                element.Add(new XCData(contents));
            }
            document.Save(this.Output);
]]>
      </Code>
    </Task>
</UsingTask>

Place the file at the same location as the .mpproj file you are interested in. Then, locate the <Import…/> directive near the bottom of the file and add the following below it:

It should look similar to this:

At this point you can restart VSAE and build your project. When you build, you will see similar build output to the following (this assumes default build verbosity settings in VS 2010):

------ Build started: Project: ManagementPack1, Configuration: Debug x86 ------
        Starting MP Build for ManagementPack1.
        Starting Fragment Verification
        Resolving Project References
        Starting Merge Management Pack Fragments
        Starting Pre Processing
        Injecting CData
        Starting MP Verify
        Resolving resources
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========

You should see an extra step in the build called “Injecting CData”.

With the Import directive added to your project, 1 new property and 1 new item is available for customization:

CDataInjectionEnabled – This MS Build property controls whether CData sections are actually injected into the MP. The default value is true, but you can set it to false if, for some reason, you wish to turn off the injection functionality without removing the new import.

CDataInjectorPath – This MS Build item controls which paths in the XML files will be considered for CData section injection. The paths are specified in XPath 1.0 format. If the path resolved to an XML tag with sub-tags, the tag will be skipped and a CData section will not be injected.

The current version will attempt to inject CData sections for every ScriptBody tag (//ScriptBody) and for every Contents tag that appears under a File tag that appears under a Files tag (/Files/File/Content). I may have missed some locations where scripts appear, so feel free to customize the list yourself (and don’t forget to let me know, so I can update the article).

Happy injecting! :)

Map Dashboard in SC 2012 Operations Manager

2012-05-21T18:34:00Z

Today, I will show you how you can create a map dashboard that displays availability and monitoring data for configured Web Application Availability tests. I will walk you through the bare minimum steps needed to display a map dashboard with some useful data.

Prerequisites

To complete this tutorial, you will need the following:

A System Center 2012 Operations Manager management group with at least 1 agent and 1 management server.
A machine with the Operations Console installed.
15-25 minutes of available time

Locations

All monitoring workflows that are run by Operations Manager are hosted by either an Agent or a Management Server. SC 2012 Operations Manager allows you to associate a location with the following:

One or more agents
One or more management servers
One or more resource pools

This is accomplished through PowerShell. Let’s open the Operations Manager Shell:

SCOM 2012 ships with several cmdlets to manage locations:

Cmdlet Name	Description
Get-SCOMLocation	This cmdlet can be used to list all the locations configured in a management group. It can also be used to obtain a location of a particular agent, management server, resource pool, or a managed entity.
New-SCOMLocation	This cmdlet creates a new location with the specified display name, longitude and latitude.
Remove-SCOMLocation	This cmdlet removes an association between a location and a set of agents, management servers, or resource pools. It can also be used to remove the location from the management group.
Set-SCOMLocation	This cmdlet associates an existing location with a set of agents, management servers, or resource pools in the management group.
Update-SCOMLocation	This cmdlet updates the specified location with a new display name, longitude, or latitude.

Create New Locations

The environment I’m using to write this article consists of a management server and an agent. I will associate them with the following locations:

Display Name	Latitude	Longitude
Redmond, WA	47.6739882	-122.121512
Chicago, IL	41.850033	-87.6500523

To create the above locations, execute the following script in the shell:

PS C:\> New-SCOMLocation -DisplayName "Redmond, WA" -Latitude 47.6739882 -Longitude -122.121512

PS C:\> New-SCOMLocation -DisplayName "Chicago, IL" -Latitude 41.850033 -Longitude -87.6500523

To verify that the locations have been created successfully, execute the following:

PS C:\> Get-SCOMLocation

Your output should be similar to the following:

PS C:\> Get-SCOMLocation

Name                                         : 6775251e-c851-4a6f-b6ab-90faeb87d9a1
Path                                         :
DisplayName                                  : Redmond, WA
FullName                                     : System.GeoLocation:6775251e-c851-4a6f-b6ab-90faeb87d9a1
ManagementPackClassIds                       : {a7f774ed-534c-08af-2fbf-54cbe1745388}
LeastDerivedNonAbstractManagementPackClassId : a7f774ed-534c-08af-2fbf-54cbe1745388
TimeAdded                                    : 5/21/2012 7:28:07 PM
LastModifiedBy                               : 7431e155-3d9e-4724-895e-c03ba951a352
Values                                       : {6775251e-c851-4a6f-b6ab-90faeb87d9a1, 47.6739882, -122.121512, System.C
                                               onfigItem.ObjectStatusEnum.Active...}
LastModified                                 : 5/21/2012 7:28:08 PM
IsNew                                        : False
HasChanges                                   : False
Id                                           : 28409a53-d0c0-c163-2f4c-3d16b76de26c
ManagementGroup                              : marcin-mg
ManagementGroupId                            : 8f2d17ec-fe46-dded-0534-cdc8ad551e67

Name                                         : 314f1262-063a-4435-a479-d12b0387499b
Path                                         :
DisplayName                                  : Chicago, IL
FullName                                     : System.GeoLocation:314f1262-063a-4435-a479-d12b0387499b
ManagementPackClassIds                       : {a7f774ed-534c-08af-2fbf-54cbe1745388}
LeastDerivedNonAbstractManagementPackClassId : a7f774ed-534c-08af-2fbf-54cbe1745388
TimeAdded                                    : 5/21/2012 7:28:58 PM
LastModifiedBy                               : 7431e155-3d9e-4724-895e-c03ba951a352
Values                                       : {314f1262-063a-4435-a479-d12b0387499b, 41.850033, -87.6500523, System.Co
                                               nfigItem.ObjectStatusEnum.Active...}
LastModified                                 : 5/21/2012 7:28:58 PM
IsNew                                        : False
HasChanges                                   : False
Id                                           : 81e88875-f33e-c518-363d-5cdbf345c55c
ManagementGroup                              : marcin-mg
ManagementGroupId                            : 8f2d17ec-fe46-dded-0534-cdc8ad551e67

Associate Locations

Now that we have locations in our management group, let’s associate one of them with a management server and another with an agent. Execute the following in the shell:

PS C:\> $redmond = Get-SCOMLocation -DisplayName "Redmond, WA"
PS C:\> $chicago = Get-SCOMLocation -DisplayName "Chicago, IL"

Verify that $redmond variable is assigned by executing the following (your output should look similar):

PS C:\> $redmond

Do the same for the $chicago variable.

Now, use the Get-SCOMAgent cmdlet to find an agent in your management group. Assign the agent to the $agent variable. Then, use the Get-SCOMManagementServer cmdlet to find a management server in your management group and assign the server to the $server variable. (These steps are specific to your own environment. I can’t provide you instructions that will work there.)

Verify that the $server and $agent variables are assigned.

Execute the following in the shell:

PS C:\> Set-SCOMLocation -Agent $agent -Location $chicago
PS C:\> Set-SCOMLocation -ManagementServer $server -Location $redmond

The locations should be associated correctly now. You can verify that by executing the following in the shell:

PS C:\> Get-SCOMLocation -ManagementServer $server
PS C:\> Get-SCOMLocation -Agent $agent

The output of either command should be a location object.

Web Application Availability Monitoring

By now, we have created the locations and associated them with a management server and an agent. Now we need to configure Web Application Availability monitoring.

Configure the monitoring

Let’s open the Operations Console and switch to the Authoring pane. Expand the Management Pack Templates tree and click on Web Application Availability Monitoring. Right-click on it and click Add Monitoring Wizard….

Make sure that Web Application Availability Monitoring is selected and click Next. On the next page, please enter a name for the template (I will use “My Monitoring”) and select an MP where the template will live.

Click Next when done. On the next page, please enter a name and a URL to monitor. I will use http://localhost, but feel free to use any internal or external URL.

Click Next when done. On the next page, click the Add… button to add a location from where you want the URL to be monitored. In the dialog that appears ensure that the Search for field is set to Internal location – Agent and click Search. Several locations will appear in the list:

Select two items that match the agent and server from the previous steps in this tutorial (specific to your environment). Once the two items are selected, click Add:

Click OK and then Next. On the next page, click Run Test to verify that the tests will work.

Click Close and then Next. Verify that everything is correct at the Summary page and click Create. You should see the new template in the Web Application Availability Monitoring folder:

View the Map Dashboard

Now that our monitoring is configured, let’s take a look at the map dashboard. In the Operations Console switch to the Monitoring pane and navigate to Application Monitoring \ Web Application Availability Monitoring folder and expand it. Click the Web Application Status dashboard in the folder. You may see something like this:

It may take some time for the monitoring to become active. Please wait until the dashboard looks like this:

Select My Monitoring and click the Summary Dashboard – Map link in the Tasks pane. This will open a new window that should be similar to this:

This dashboard is showing the locations from which Web Availability Monitoring tests are running from. If you recall from previous steps, we configured the tests to run from an agent and server that had geographic locations associated with them. This information is used to populate this dashboard.

If you zoom in a bit, you’ll see that the green checkmarks are located by Redmond, WA and Chicago, IL:

If you select one or more locations in the map (use Ctrl select to select multiple or deselect items), the Test Status portion of the dashboard will light up. Select the Chicago location:

Select the item in the Test Status table and click the Detailed Dashboard – List link in the Tasks pane. This will bring up a dashboard that displays performance data collected from Web Application Availability tests:

Select one or more locations and put a check mark by at least one of the items under Test Status. You should see something like this:

It may take some time for the data to appear in the dashboard.

Congratulations! You now know how to associate locations with agents and/or servers and how to display that information using the Summary Map Dashboard.

Setting up a comparer application in MPBPA v2

2009-11-15T00:24:29Z

Introduction

In my previous post, I discussed how you can use MPBPA v2 to automatically fix common issues in MPs. In order to preview the changes that MPBPA v2 makes to MPs when fixing issues, you need to have a comparer application configured in MPBPA v2. The previous post assumes that WinDiff was already configured in your environment. Today, we will discuss how to configure other applications that can preview MP changes.

In order to configure the comparer application, click Configure that is located in the top left corner of the MPBPA v2 window. (The previous post explains how to get that window to open.)

Clicking Configure will open the following window (assuming you left the default configuration intact):

Open the Preferences tab by clicking on it:

Here you can configure your comparer application by either clicking Browse and selecting it or by entering a full path to its executable.

MPBPA v2 can run any application that you configure. For the preview functionality to work correctly, your application must support the following command-line argument convention: <Application> <before> <after>

When MPBPA v2 runs the comparer applications, the following substitutions are made:

<Application>	This is the application’s executable that you configure using the above dialog.
<before>	MPBPA v2 will put the absolute path to the xml file containing the management pack before the proposed change is made.
<after>	MPBPA v2 will put the absolute path to the xml file containing the management pack after the change is made.

Mp Diff

The easiest comparer application to set up with MPBPA v2 is Mp Diff. Mp Diff is a management pack comparer tool that calculates the net changes between two management packs and displays a report using the default system browser. Mp Diff is installed with the rest of System Center Operations Manager 2007 R2 Authoring Resource Kit. It is accessible from Start \ All Programs \ System Center Operations Manager 2007 R2 \ Authoring Tools \ Mp Diff (this path may vary if you use an older version of Windows).

To use Mp Diff with MPBPA v2, simply point MPBPA v2 to the location of MpDiff.exe. It will most likely be installed in \System Center MP Authoring Console 2007\MpDiff\MpDiff.exe under your Program Files folder (most often C:\Program Files\ or C:\Program Files (x86)\).

Once it’s configured you should see something similar to this in the Configure window:

Here’s a screenshot of Mp Diff being used by MPBPA v2 to fix the MP from the previous post:

WinDiff

WinDiff is a file comparer utility that has been around for ages. To set it up you will need to download it first. Then simply point MPBPA v2 to the location of WinDiff.exe and off you go:

You can see WinDiff in action with MPBPA v2 in the previous post:

Batch File

What if the tool you want to use for previewing with MPBPA v2 does not accept command-line arguments the MPBPA v2 way? The solution is simple. Write a batch file that converts the MPBPA v2 calling convention to your tool’s calling convention. Here’s an example of such a batch file:

   1:  @echo off

   2:  echo Before MP: %1

   3:  echo After MP: %2

   4:  start iexplore %1

   5:  start notepad %2

   6:  pause

The above script displays the two file names used by MPBPA v2 to save the temporary xml files, starts opens the file before changes with Internet Explorer and opens the file after the changes with Notepad. The script has no real purpose, but it illustrates the flexibility of what you can do. What your script does is really up to you, but I expect that you would simply call some command with %1 and %2 to indicate the before changes and after changes MP files, respectively. Keep in mind that MPBPA v2 does not monitor %1 and %2 for any changes, so if you edit those files your self, the changes will be ignored.

Here are the screenshots of the script in action with the MP from the previous post.

This posting is provided "AS IS" with no warranties.
Use of included tools and reports are subject to the terms specified at
http://www.microsoft.com/info/cpyright.htm

Fixing common MP issues using MPBPA v2

2009-11-13T08:20:00Z

Today, we will take a look at MPBPA v2’s ability to automatically fix problems it finds in management packs. To illustrate this behavior, I attached a small sample MP that has a few best practice violations that can be fixed by MPBPA v2. (MPBPA v2 is available from the System Center Operations Manager 2007 R2 Authoring Resource Kit.

After downloading the sample MP, open it in the Authoring Console. Then, click Tools \ Analyze with MPBPA…:

This will bring up a window similar to this:

If you see something different, make sure that you are checking for all best practice violations. The easiest way to do that is by clicking Configure and then Restore default configuration in the window that opens.

Looking at the window above, check all the available check boxes by either clicking Check All or manually clicking each violation displayed. This will enable the Fix Checked Violation(s) button:

Click Fix Checked Violation(s). The following window will appear:

As you can see, the Description field has a red exclamation point near it. This means that the data entered in the field is invalid. Hover the cursor anywhere over the field or the exclamation point to find out why the entered data is invalid:

Entering some description will enable Preview and Fix buttons as well as the Fix all similar violations using same inputs.

Clicking Preview will display a preview of the fix about to be made to the management pack using the preview tool that you have configured. If you have a preview tool configured, click Preview. If you had WinDiff configured, something similar to this would appear:

This is the only change that fixing will make to the MP. A missing MP description requires that we add the missing tag and an appropriate value. Let’s click Fix to make the change. Since the other two checked violations do not require any user input, MPBPA will just fix them. The result will be similar to this:

At this point, you can click Rescan to confirm that fixed violations are really gone, but you don’t have to. Simply close the MPBPA v2 window and save the MP in the Authoring Console.

MPBPA v2 is capable of automatically fixing many common issues with MPs and identifying many more. If you’d like some more information about a particular issue, simply highlight it and click Link to help:

When you do that, a knowledge article will be displayed using your default browser with information about the selected issue. Good luck and happy fixing!

This posting is provided "AS IS" with no warranties.
Use of included tools and reports are subject to the terms specified at
http://www.microsoft.com/info/cpyright.htm

All References Tips and Tricks: Time-savers

2009-10-31T00:14:01Z

There are certain things that you can do with the All References add-in that are not immediately obvious while using it. Here are some of them:

Non-Modal Windows

The search result windows displayed by the add-in are non-modal. As a result, you can have as many windows open as you want. If you search for references to an element that already has a corresponding search result window open, the contents of the window will be updated.

References to References

Sometimes you may need to follow a chain of references wherever it may take you. If the reference you found is in the same MP that is currently open in the Authoring Console, it is rather easy. You can simply find the element in the MP using the Authoring Console, right-click on it, and click Show References. But what do you do if the reference found is in another MP? Normally, you would have to open that MP in the same or another instance of the Authoring Console, find the element, right-click it, and click Show References.

There is an easier way, however. Simply double-click an item in the add-in’s result window and it will find references to it. (It doesn’t matter in which MP it is declared.)Alternatively, you can right-click the item and click Show References:

Of course, you can continue double-clicking to find references to references to references, and so on.

References to Multiple MP Elements

The All References Add-in lets you find references to multiple elements. Simply select multiple MP elements (either in the Authoring Console or in one of add-in’s windows), right-click on one of the selected elements, and click Show References. For each selected element, the add-in will display a separate window with the results.

Copy Results to Excel

Selecting one or more MP elements in the add-in’s search results window and pressing Ctrl + C or clicking Copy in the context menu will copy the element name, management pack name, management pack version, and management pack key token to the clipboard in a tab-separated format without headers. You can easily paste that into your favorite spreadsheet application while maintaining some of the formatting.

Making Results Less Verbose

Once you’re familiar with the way the All References Add-in presents its results, you may find it a bit verbose. To help matters, you use the following two options:

Show Group Descriptions	This option switches between long and short descriptions for groups used to separate MP elements in the add-in’s result windows. It is also accessible by pressing F2.
Show Empty Groups	This option switches between showing and hiding empty MP element groups in the add-in’s result windows. It is also accessible by pressing F3.

Updating Reference Cache

Sometimes, you may find yourself changing the Authoring Console’s reference folders. You might add, remove, or update the MPs contained there or you might even add or remove the reference folders to/from the Authoring Console. If this happens, the All References Add-in must rebuild its cache in order to avoid inaccurate results.

One way to force a cache update is to simply restart the Authoring Console.

However, a quicker way is to right-click in any of the add-in’s result windows and click Update Reference Cache:

This will display the following confirmation dialog:

Click Yes and run your search again. The new result will reflect changes that you made to the cache (if any).

Getting Help

Most of the tools that were included in the Authoring Resource Kit display a help file when you press F1. It’s quicker than clicking Start \ All Programs \ System Center Operations Manager 2007 R2 \ Authoring Tools \ Resource Kit Help.

This posting is provided "AS IS" with no warranties.
Use of included tools and reports are subject to the terms specified at
http://www.microsoft.com/info/cpyright.htm

All References Tips and Tricks: Improving Memory Utilization

2009-10-30T19:15:58Z

The All References Add-in is described in some detail in the previous post.

If you often open MPs that are referred to by a lot of other MPs (in your reference folders), you may find that the All References Add-in consumes a lot of memory during its search. This only applies to often-used library MPs such as the ones that ship with System Center Operations Manager 2007 and any of the later versions.

If you often find yourself in this situation, this article is for you. If you do not see any problems with memory utilization when using the All References Add-in, I would not recommend applying the changes described in the rest of this post.

There exists a hidden setting that allows you to control how the add-in optimizes its search. It is called SearchOptimization and it has the following 2 allowed values:

Time

This is the default value for this setting. With this set, the add-in will perform the search as fast as possible at the cost of using more memory. The actual memory consumption is proportional to the number of MPs that refer to the currently open MP. With this setting, only the first search takes some time. Subsequent searches are instant. The majority of MPs do not have many MPs referring to them. As such, this setting will work perfectly without any significant memory consumption issues.

Memory

Setting SearchOptimization to Memory causes the add-in to perform the search more slowly. However, the memory consumption is fixed and does not grow with the number of MPs that refer to the currently open MP. The first and subsequent searches take exactly the same amount of time. It is appropriate to use this setting in situations when you have a large number of MPs in your reference folders and you often want to find references to MP elements declared in system libraries. (And only if your machine has very little RAM.)

In order to change the setting from the default, you need to find your Authoring Resource Kit installation directory. It should be either C:\Program Files\System Center MP Authoring Console 2007 or C:\Program Files (x86)\System Center MP Authoring Console 2007. In that directory, there is a file called Microsoft.EnterpriseManagement.UI.MPAuthoring.exe.config. (If Windows Explorer is hiding extensions of known file types, you will only see Microsoft.EnterpriseManagement.UI.MPAuthoring.exe and file type XML Configuration File.)

Make a backup copy of the file just in case something goes wrong.

Open that file with your favorite text or XML editor. If you are using Windows Vista or later, you will need to run the editor as Administrator.

Find the following snippet in the opened file:

   1:  <Addin>

   2:    <Type>Microsoft.EnterpriseManagement.AuthoringExtensibility.AllReferencesAddin.AllReferencesAddin,Microsoft.EnterpriseManagement.AuthoringExtensibility.AllReferencesAddin</Type>

   3:    <Settings>

   4:      <Setting>

   5:        <add>CrossMPSearch</add>

   6:        <value>Enabled</value>

   7:      </Setting>

   8:      <Setting>

   9:        <add>CachePopulationStrategy</add>

  10:        <value>Incremental</value>

  11:      </Setting>

  12:      <Setting>

  13:        <add>ResultsFormStyle</add>

  14:        <value>ListView</value>

  15:      </Setting>

  16:      <Setting>

  17:        <add>SearchOptimization</add>

  18:        <value>Time</value>

  19:      </Setting>

  20:    </Settings>

  21:    <DefaultResourceFileName>Microsoft.EnterpriseManagement.AuthoringExtensibility.AllReferencesAddin.Resources</DefaultResourceFileName>

  22:    <Actions>

  23:      <Action TextId="ShowReferences" OnAction="ShowReferences" IconId="AllReferencesIcon_16">

  24:        <TargetType Type="^ClassType$" />

  25:        <TargetType Type="^RelationshipType$" />

  26:        <TargetType Type="^Discovery$" />

  27:        <TargetType Type="^UnitMonitor$" />

  28:        <TargetType Type="^UnitMonitorType$" />

  29:        <TargetType Type="^DependencyMonitor$" />

  30:        <TargetType Type="^AggregateMonitor$" />

  31:        <TargetType Type="^Rule$" />

  32:        <TargetType Type="^SecureReference$" />

  33:        <TargetType Type="^DataSourceModuleType$" />

  34:        <TargetType Type="^ConditionDetectionModuleType$" />

  35:        <TargetType Type="^ProbeActionModuleType$" />

  36:        <TargetType Type="^WriteActionModuleType$" />

  37:      </Action>

  38:    </Actions>

  39:  </Addin>

The following part of the above file controls the value of the SearchOptimization setting:

   1:  <Setting>

   2:    <add>SearchOptimization</add>

   3:    <value>Time</value>

   4:  </Setting>

Replace Time with Memory:

   1:  <Setting>

   2:    <add>SearchOptimization</add>

   3:    <value>Memory</value>

   4:  </Setting>

Save the file and run the Authoring Console. If the Authoring Console should not display any error messages if the file was modified correctly. (Make sure you have a backup or you will have to uninstall and reinstall the Authoring Resource Kit to restore the file.)

If you want to go back to the previous setting, just change Memory back to Time and restart the Authoring Console.

This posting is provided "AS IS" with no warranties.
Use of included tools and reports are subject to the terms specified at
http://www.microsoft.com/info/cpyright.htm

Finding references to MP elements in other MPs using the All References Add-in

2009-10-30T17:53:00Z

The All References Add-in is one of the tools included with the System Center Operations Manager 2007 R2 Authoring Resource Kit that shipped recently. It allows you to find references to the selected MP element in the currently opened MP in the Authoring Console as well as any MP that refers to the currently-open MP. (Provided that the currently open MP and the MPs that refer to it are included in the Authoring Console’s reference folders.)

Let’s download an MP to see how this works. Any MP will do, but for the purposes of this blog post, I will use the latest version of the BaseOS MP. Download it and install it. (Any location on your system will work. I used the default suggested by the installer: C:\Program Files (x86)\System Center Management Packs\Windows Server Base OS System Center Operations Manager 2007 MP.)

Open the Authoring Console and click Tools \ Options…

The Options dialog will appear. Click the References tab:

Your reference paths may not necessarily be empty. Click Add… and select the installation directory of the BaseOS MP:

Click OK. Your Reference Paths should now contain the BaseOS MP installation directory. Highlight it and keep clicking the Up arrow button until the directory is at the top of the list:

Click OK and restart the Authoring Console. When the console starts up again, open the Microsoft.Windows.Server.Library.mp from the BaseOS MP installation directory using the File \ Open… option of the Authoring Console. Once the MP opens, open the Service Model pane and click Classes. The following list of classes should appear:

Select Microsoft.Windows.Server.NetworkAdapter, right-click it, and click Show References:

After the add-in completes the search, you should see the following window:

To hide the empty groups in the window, either press F3 or right-click and uncheck Show Empty Groups like so:

The result will be:

This means that the following classes derive from class Microsoft.Windows.Server.NetworkAdapter declared in MP Microsoft.Windows.Server.Library:

Class Microsoft.Windows.Server.2000.NetworkAdapter (declared in MP Microsoft.Windows.Server.2000)
Class Microsoft.Windows.Server.2003.NetworkAdapter (declared in MP Microsoft.Windows.Server.2003)
Class Microsoft.Windows.Server.2008.NetworkAdapter (declared in MP Microsoft.Windows.Server.2008.Discovery)

In addition, the add-in found 6 views that target class Microsoft.Windows.Server.NetworkAdapter in MP Microsoft.Windows.Server.Library.

With the All References add-in, you can find other references to many different MP elements. For a full list, either press F1 in the above window or click Start \ All Programs \ System Center Operations Manager 2007 R2 \ Authoring Tools \ Resource Kit Help:

I hope this was an interesting introduction to the All References Add-in. As always, all feedback, comments, and questions are appreciated.

This posting is provided "AS IS" with no warranties.
Use of included tools and reports are subject to the terms specified at
http://www.microsoft.com/info/cpyright.htm

System Center Operations Manager 2007 R2 Authoring Resource Kit has been released

2009-10-27T17:19:00Z

This post may be a little late since the resource kit was released last week, but better late than never.

The resource kit contains the SCOM 2007 R2 Authoring Console and several tool that enhance its functionality to help with authoring, development, maintenance, and reviewing of management packs. You can download the resource kit from the Microsoft Download Center.

The following tools have been included in the resource kit:

· Management Pack Best Practices Analyzer (MPBPA) - scans management packs for best practice violations and allows you to automatically fix a number of issues.

· Management Pack Spell Checker (MP Spell Checker) - helps you eliminate errors in display strings.

· Management Pack Visio Generator (MP Visio Generator) - generates a class inheritance and class relationship diagram using Microsoft Office Visio.

· Management Pack Diff (MP Diff) - compares two management packs and presents differences between them.

· Management Pack Cookdown Analyzer (MP Cookdown Analyzer) - identifies workflows which may break cook-down, and provides suggestions on how to fix performance issues.

· All References Add-in - helps find all references to the selected MP element.

· Workflow Analyzer - provides the ability to statically analyze all types of workflows.

· Workflow Simulator - provides the ability to test certain types of workflows such as discoveries, rules, and monitors without a Management Server and Management Group.

Enjoy!

Hard-coded Management Pack Discoveries

2009-06-01T05:46:00Z

Typically when developing management packs, the following is done more or less in order:

Object model (classes and relationships)
Discoveries (to discover classes and relationships)
Monitoring workflows (to target the discovered classes and relationships)

What if the product you will manage with your MP has some experimental or poorly documented API that you would like to use for monitoring. Let's say you want to experiment with it a bit to determine whether or not it is viable for your purposes. In addition, assume that the discovery for that particular application is somewhat tricky and will take time to fully implement. (If the aforementioned API turns out to be a disappointment, all the discovery work will be wasted.)

So why not just hard code the discovery for testing purposes?

To accomplish this, do the following:

Create a composite data source module type consisting of a System.Discovery.Scheduler data source and a System.Discovery.ClassSnapshotDataMapper condition detection module (both from System.Library MP)
Create a discovery that uses your newly created data source.

The following is an example of a data source module type from step 1:

   1:  <DataSourceModuleType ID="MarcinAtWork.HardcodedDiscovery.One.DemoApplicationDiscovery.DS" Accessibility="Internal" Batching="false">

   2:    <Configuration>

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

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

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

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

   7:    </Configuration>

   8:    <OverrideableParameters>

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

  10:      <OverrideableParameter ID="SyncTime" Selector="$Config/SyncTime$" ParameterType="string" />

  11:      <OverrideableParameter ID="SomeString" Selector="$Config/SomeString$" ParameterType="string" />

  12:    </OverrideableParameters>

  13:    <ModuleImplementation Isolation="Any">

  14:      <Composite>

  15:        <MemberModules>

  16:          <DataSource ID="DS" TypeID="System!System.Discovery.Scheduler">

  17:            <Scheduler>

  18:              <SimpleReccuringSchedule>

  19:                <Interval Unit="Seconds">$Config/IntervalSeconds$</Interval>

  20:                <SyncTime>$Config/SyncTime$</SyncTime>

  21:              </SimpleReccuringSchedule>

  22:              <ExcludeDates />

  23:            </Scheduler>

  24:          </DataSource>

  25:          <ConditionDetection ID="CD" TypeID="System!System.Discovery.ClassSnapshotDataMapper">

  26:            <ClassId>$MPElement[Name="MarcinAtWork.HardcodedDiscovery.One.DemoApplication"]$</ClassId>

  27:            <InstanceSettings>

  28:              <Settings>

  29:                <Setting>

  30:                  <Name>$MPElement[Name="Windows!Microsoft.Windows.Computer"]/PrincipalName$</Name>

  31:                  <Value>$Target/Property[Type="Windows!Microsoft.Windows.Computer"]/PrincipalName$</Value>

  32:                </Setting>

  33:                <Setting>

  34:                  <Name>$MPElement[Name="MarcinAtWork.HardcodedDiscovery.One.DemoApplication"]/SomeInteger$</Name>

  35:                  <Value>$Config/SomeInteger$</Value>

  36:                </Setting>

  37:                <Setting>

  38:                  <Name>$MPElement[Name="MarcinAtWork.HardcodedDiscovery.One.DemoApplication"]/SomeString$</Name>

  39:                  <Value>$Config/SomeString$</Value>

  40:                </Setting>

  41:              </Settings>

  42:            </InstanceSettings>

  43:          </ConditionDetection>

  44:        </MemberModules>

  45:        <Composition>

  46:          <Node ID="CD">

  47:            <Node ID="DS" />

  48:          </Node>

  49:        </Composition>

  50:      </Composite>

  51:    </ModuleImplementation>

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

  53:  </DataSourceModuleType>

The following is an example of the discovery from step 2:

   1:        <Discovery ID="MarcinAtWork.HardcodedDiscovery.One.DemoApplicationDiscovery" Enabled="true" Target="Windows!Microsoft.Windows.Computer" ConfirmDelivery="true" Remotable="true" Priority="Normal">

   2:          <Category>Discovery</Category>

   3:          <DiscoveryTypes>

   4:            <DiscoveryClass TypeID="MarcinAtWork.HardcodedDiscovery.One.DemoApplication">

   5:              <Property TypeID="MarcinAtWork.HardcodedDiscovery.One.DemoApplication" PropertyID="SomeInteger" />

   6:              <Property TypeID="MarcinAtWork.HardcodedDiscovery.One.DemoApplication" PropertyID="SomeString" />

   7:              <Property TypeID="System!System.Entity" PropertyID="DisplayName" />

   8:            </DiscoveryClass>

   9:            <DiscoveryRelationship TypeID="Windows!Microsoft.Windows.ComputerHostsLocalApplication" />

  10:          </DiscoveryTypes>

  11:          <DataSource ID="DS" TypeID="MarcinAtWork.HardcodedDiscovery.One.DemoApplicationDiscovery.DS">

  12:            <IntervalSeconds>120</IntervalSeconds>

  13:            <SyncTime />

  14:            <SomeInteger>42</SomeInteger>

  15:            <SomeString>Some test string goes here.</SomeString>

  16:          </DataSource>

  17:        </Discovery>

The entire management pack containing the above snippets is attached to this post. In addition to the above, I included another discovery that uses a System.Discovery.FilteredClassSnapshotDataMapper (also from System.Library MP) to demonstrate how you can use an expression to determine whether or not a discovery should run on a particular computer.

If you import the attached MP (make sure to change string "NLB-CL7-N2.marcin.com" in the MP to a fully-qualified device name of one computer in your maanagement group), the following should happen:

Instances of class MarcinAtWork.HardcodedDiscovery.One.DemoApplication will be discovered on every computer in your management group.
One instance of class MarcinAtWork.HardcodedDiscovery.One.DemoApplicationSingle will be discovered on the computer whose FQDN you entered in the MP before importing it.

Good luck!

This posting is provided "AS IS" with no warranties.
Use of included tools and reports are subject to the terms specified at
http://www.microsoft.com/info/cpyright.htm

First Post!

2009-05-26T19:36:00Z

Welcome to my blog!

I'm Marcin Jastrzebski and I'm a developer on the System Center Operations Manager (SCOM). In time, this blog will contain various SCOM-related information that I feel might be useful to you. This may include tools, Management Pack or SCOM SDK development tips, feature demos, or pretty much anything else.

This posting is provided "AS IS" with no warranties.
Use of included tools and reports are subject to the terms specified at
http://www.microsoft.com/info/cpyright.htm