David Allen - Cloud & Datacenter Management MVP : Authoring

VSAE – Go To Definition

David Allen MVP — Wed, 23 Jan 2013 14:02:28 GMT

For the past couple of months I have been using the Visual Studio Authoring Extensions quite extensively to build management packs for System Center, so I thought I would share some of what I have learnt, and I am starting with “Go To Definition”. Now, for experienced users of Visual Studio this will be nothing new, but if you are starting with VS because of the Authoring Extensions, this is really helpful.

The Go To Definition command is a neat little command to take you straight to the definition of a module that you are using within a management pack. To show the usefulness of this, here is a little example.

You start building a new MP in VS, and you start writing your registry discovery….

You get to the point where you want to call the Microsoft.Windows.FilteredRegistryDiscoveryProvider to use as a discovery data source, but what configuration items need to be passed to this module?

To find out, simply right click the TypeID, in this case “Windows"!Microsoft.Windows.FilteredRegistryDiscoveryProvider” and select Go To Definition. This will open the referenced management pack in a new tab in VS and take you straight to that module, where you can view the configuration items required for the module (highlighted in yellow).

I find this extremely useful and a great time saver, as not only does it take you to the correct line in the referenced MP, it also means you don’t have to worry about unsealing the referenced MP!

More (hopefully) helpful tips to come.

David

Passing Data Items to Recovery Actions

David Allen MVP — Thu, 30 Aug 2012 14:12:00 GMT

I was tasked the other day with creating a recovery action on a monitor, which in itself is not complicated, however I needed to use a data item from the monitor workflow in the recovery. On searching, I found very little documentation about how to achieve this, but I did find a helpful example Diagnostic and Recovery MP from Brian Wren (as usual) here, http://www.opsmanjam.com/default.aspx?RootFolder=%2fOpsManJam%20Library%2fManagement%20Packs&FolderCTID=&View=%7bB441DC0E%2d3F55%2d42C6%2d8C9E%2d0FA229F8DBDD%7d. This example MP is great for showing how to run a diagnostic and then use the output of the diagnostic in the recovery action. However, the requirement I had was run a recovery action directly, without a diagnostic, based on a data item returned from the workflow.

After some investigation, I cracked it, and these are a couple of examples of the context parameters that can be used.

1. If the monitor returns a property bag, data from the property bag can be resolved using “$Data/StateChange/DataItem/Context/DataItem/Property[@Name='ITEM']$”. (Replace ITEM with the name of the property bag value)

2. If the monitor using a module where the data items are already mapped, the data can be resolved using something like this “$Data/StateChange/DataItem/Context/DataItem/EventDescription$”. In this example, the monitor is using the EventProvider module to monitor to an event log, and the description of the event is being passed.

So, now we have the correct context parameters, we can resolve the data items we need in a recovery action. Here’s an example where I have a script monitor that it monitoring for an existence of a file, if the file doesn’t exist this will trigger an unhealthy state and the recovery action, which will output the file name, from the monitor, to the event log.

<UnitMonitor ID="Recovery.Example.Monitor.ScriptTwoState" Accessibility="Public" Enabled="false" Target="Windows!Microsoft.Windows.Computer" ParentMonitorID="Health!System.Health.AvailabilityState" Remotable="true" Priority="Normal" TypeID="Windows!Microsoft.Windows.TimedScript.TwoStateMonitorType" ConfirmDelivery="false">
        <Category>AvailabilityHealth</Category>
        <AlertSettings AlertMessage="Recovery.Example.Monitor.ScriptTwoState_AlertMessageResourceID">
          <AlertOnState>Error</AlertOnState>
          <AutoResolve>true</AutoResolve>
          <AlertPriority>Normal</AlertPriority>
          <AlertSeverity>Error</AlertSeverity>
        </AlertSettings>
        <OperationalStates>
          <OperationalState ID="Success" MonitorTypeStateID="Success" HealthState="Success" />
          <OperationalState ID="Error" MonitorTypeStateID="Error" HealthState="Error" />
        </OperationalStates>
        <Configuration>
          <IntervalSeconds>301</IntervalSeconds>
          <SyncTime />
          <ScriptName>Example.vbs</ScriptName>
          <Arguments />
          <ScriptBody><![CDATA[Option Explicit

SetLocale("en-us")

Dim oAPI, oBag
Set oAPI = CreateObject("MOM.ScriptAPI")
Set oBag = oAPI.CreatePropertyBag()

Call oAPI.LogScriptEvent("Example.vbs",5555,4,"Script Started")

DIM oFso, strFile
Set oFso = CreateObject("Scripting.FileSystemObject")
strFile = "C:\Temp\test.txt"

If (oFso.FileExists(strFile)) Then

Call oBag.AddValue("Status","OK")
Else
Call oBag.AddValue("Status","BAD")
Call oBag.AddValue("File",strFile)
End If

Call oAPI.LogScriptEvent("Example.vbs",5555,4,"Script Finished")

Call oAPI.Return(oBag)
              ]]></ScriptBody>
          <SecureInput />
          <TimeoutSeconds>60</TimeoutSeconds>
          <ErrorExpression>
            <SimpleExpression>
              <ValueExpression>
                <XPathQuery Type="String">Property[@Name='Status']</XPathQuery>
              </ValueExpression>
              <Operator>Equal</Operator>
              <ValueExpression>
                <Value Type="String">BAD</Value>
              </ValueExpression>
            </SimpleExpression>
          </ErrorExpression>
          <SuccessExpression>
            <SimpleExpression>
              <ValueExpression>
                <XPathQuery Type="String">Property[@Name='Status']</XPathQuery>
              </ValueExpression>
              <Operator>Equal</Operator>
              <ValueExpression>
                <Value Type="String">OK</Value>
              </ValueExpression>
            </SimpleExpression>
          </SuccessExpression>
        </Configuration>
      </UnitMonitor>
    </Monitors>
    <Recoveries>
      <Recovery ID="Recovery.Example.Recovery" Accessibility="Public" Enabled="true" Target="Windows!Microsoft.Windows.Computer" Monitor="Recovery.Example.Monitor.ScriptTwoState" ResetMonitor="false" ExecuteOnState="Error" Remotable="true" Timeout="300">
        <Category>Operations</Category>
        <WriteAction ID="Script" TypeID="Windows!Microsoft.Windows.ScriptWriteAction">
          <ScriptName>Recovery.vbs</ScriptName>
          <Arguments>$Data/StateChange/DataItem/Context/DataItem/Property[@Name='File']$</Arguments>
          <ScriptBody><![CDATA[
Option Explicit

SetLocale("en-us")

Dim oArgs, strFile
Set oArgs = Wscript.Arguments
strFile = oArgs(0)

Dim oAPI
Set oAPI = CreateObject("MOM.ScriptAPI")

Call oAPI.LogScriptEvent("Recovery.vbs",5556,4,"File: " & strFile)

]]></ScriptBody>
          <TimeoutSeconds>300</TimeoutSeconds>
        </WriteAction>
      </Recovery>
    </Recoveries>

Note: This is just an example for demonstration purposes, it is not a real production monitor.

The full example MP is downloadable here.

Hope that’s helpful and makes the use of recovery actions more appealing

David

Windows Service Monitoring During Specific Hours

David Allen MVP — Tue, 14 Aug 2012 08:08:08 GMT

If you ever wanted to monitor Windows services, but only during business hours, then this is the post for you. I have put together an example MP that contains a new monitor type that includes a Schedule Filter so you can specify when the monitor should or shouldn’t run. The new monitor type is fundamentally the same as the monitor type for service monitoring that is included in the Microsoft.Windows.Library MP, but now has System.SchedulerFilter included.

Here is a breakdown of the modules used within the monitor type:

Microsoft.Windows.Win32ServiceInformationProvider – This data source returns the state of a service.
System.SchedulerFilter – A condition detection where it is possible to specify the times in which the data should or should not be processed.
System.ExpressionFilter – This module is used twice, one to filter a service running condition, and one to filter a service not running condition.

After the member modules are configured, the composition of the monitor type can be put together for the OK state (service running) and the BAD state (service not running).

I have also included a monitor in the management pack that uses this new monitor type. The configuration of the monitor is just the same as the configuration of the standard service monitors, but with the added parameters of Start, End and DaysOfWeekMask.

The Start parameter allows you to specify at what time monitoring should start, and the End parameter allows you specify when the monitoring should end. The DaysOfWeekMask is a number that controls which days the monitor will run. For a list of all the possible values for the DaysOfWeekMask, use this TechNet article, http://technet.microsoft.com/en-us/library/ee808920.aspx.

So that’s it, you can take my example MP and edit it to achieve the monitoring you are after. You can also open up the MP in one of the authoring tools and change as required; as I mentioned above, the scheduler filter can be used not only to specify when data can be processed, but it may also be used to control when data should not be processed, and you can span multiple days if required.

Have fun!

David

Making OpsMgr Dashboards More Dynamic…

David Allen MVP — Thu, 09 Aug 2012 10:15:41 GMT

Yesterday, Brian Wren at Microsoft released a sample widget for OpsMgr 2012 dashboards, which shows how you can make dashboards much more dynamic and displays some of the dashboard functionality I would have liked to have seen out of the box.

The screenshot below displays the sample dashboard, and what you’ll notice is that the for performance widgets on the right are displaying data for the computers selected in the left widget. This makes the dashboard so much more powerful and useful as I can now see 4 different performance metrics just by selecting the computer once. And, then by selecting further computers, I can easily compare multiple performance metrics of multiple computers.

You can download the sample from Brian’s blog post at http://gallery.technet.microsoft.com/PerformanceMonitor-Sample-0714ddd0. Also on this webpage, Brian shares some information on how he collects the data to be displayed and defines the performance counters.

By using this sample as a base, I’m hoping we’ll all start producing some really good, and very useful, dashboards!

Enjoy.

David

Advanced Discoveries on Unix/Linux Computers

David Allen MVP — Wed, 08 Aug 2012 18:26:00 GMT

Recently, I had a requirement to discover a number of devices that existing on a Linux server, which got me thinking as previously I’ve only ever run a shell command that returns a status to determine whether an object is discovered or not. In this scenario I needed to run a script to return all the devices that existed on it, and then discover an object for each device returned. On Windows, this is pretty straightforward as you can just use a scripted discovery to discover multiple items, but on Unix/Linux computers we can’t quite do the same thing.

When thinking about it a bit further though, I realised that I could almost do the same as a Windows discovery. Because the all workflows for UNIX/Linux computers run on the management server managing the computer, and not on the agent, I can return the data I need using a script or command from the computer, and then pass that through to a Windows Script or PowerShell module where I can use a similar discovery script as I would for a Windows discovery.

So here is a breakdown of the workflow for a custom discovery data source:

System.Discovery.Scheduler – Scheduler data source to control the schedule of the discovery
Microsoft.Unix.WSMan.Invoke.ProbeAction – A probe to run a Shell Command or script on the UNIX/Linux computer that returns the data required for the discovery.
System.ExpressionFilter (Optional) – An expression filter to check that no errors were returned from the previous probe.
Microsoft.Windows.ScriptDiscoveryProbe – A probe to run a VBS script where instances can be created based on the data inputted from the previous probe using property bags.

Note: If the command or script that needs running requires a privileged account, you could swap the Microsoft.Unix.WSMan.Invoke.ProbeAction probe with the Microsoft.Unix.WSMan.Invoke.Privileged.ProbeAction. And, if you would rather use PowerShell than VBS, you could always use the Microsoft.Windows.PowerShellDiscoveryProbe instead of the Microsoft.Windows.ScriptDiscovery probe.

Once the data source is created, it is just a matter of creating a new discovery that utilises the data source and specifying the relevant details, and presto, you will start discovering!

To get a good idea on building a discovery data source for Unix/Linux computers using the 2007 R2 Authoring Console, I highly recommend reading a series on extending Unix/Linux monitoring by Kris Bash. Part 1 of the series is viewable here, http://operatingquadrant.com/2011/03/23/operations-manager-extending-unixlinux-monitoring-with-mp-authoring-part-i/.

So, with the information from the blog above, and what we know about discoveries with VBS or PowerShell, we can can hook everything together to discover multiple items on a Unix/Linux Computer.

Below I have provided an example management pack for you, so you can see how everything works. I have used a basic script to simply return the devices on a Linux server using ‘iostat’, and then create an object representing each device. I know the default monitoring MP’s already discover this, I am just using it as an example. The management pack also contains the script that gets run on the UNIX/Linux computer, it is not executing a script that is already on the computer, so this MP will work as an example if you would like to know how to embed the script and use the ExecuteScript method of the Microsoft.Unix.WSMan.Invoke.ProbeAction probe.

Management pack: ExampleMP.xml

Hope this proves useful, and enjoy!

David

OpsMgr 2012 Authoring - The Wait Is Over...

David Allen MVP — Fri, 29 Jun 2012 13:12:49 GMT

The wait for the new System Center 2012 - Operations Manager authoring tools is over!!! Brian Wren has announced on his blog that both the Visio Management Pack Designer and Visual Studio Authoring Extensions are available now from the Microsoft Download Center.

Visio Management Pack Designer download: http://www.microsoft.com/en-us/download/details.aspx?id=30170

Visual Studio Authoring Extensions: http://www.microsoft.com/en-us/download/details.aspx?id=30169

Brian's blog post: http://blogs.technet.com/b/mpauthor/archive/2012/06/28/the-new-authoring-tools-are-here.aspx

Happy authoring everyone :-)

David

Logical Disk Extension Management Pack

David Allen MVP — Thu, 15 Apr 2010 19:00:00 GMT

Recently, I had the need to run a logical disk free space report and knowing that this isn’t provided out of the box I created a report and put it into a new management pack. I was then approached about collecting fragmentation data on each drive as well and this got me thinking, why don’t I create an MP that extends the standard management of logical disks. So, I created it !

This management pack collects 21 different statistics on each managed logical drive. These counters are…

Average File Size
Average Fragments per File
Cluster Size
Excess Folder Fragments
File Percent Fragmentation
Fragmented Folders
Free Space
Free Space Percent
Free Space Percent Fragmentation
MFT Percent in Use
MFT Record Count
Total Excess Fragments
Total Files
Total Folders
Total Fragmented Files
Total MFT Fragments
Total MFT Size
Total Page File Fragments
Total Percent Fragmentation
Used Space
Volume Size

Collecting this many counters created its own challenge as I didn’t want to have to run a script multiple times to collect each counter or run it for each drive. To combat this challenge I wrote a data source that all the collection rules use. This data source contains a VBS script that will only run once per server at the scheduled time and collect all 21 pieces of data for each and every logical drive on that server. Writing a data source and rules like this means that cookdown does not get broken and is the most efficient way of collecting and monitoring data.

This management pack also contains a “Free Space” report and a “Top 10 fragmented logical drives” report as well as performance, state and dashboard views for you to consume all the collected data. And, there is also a task to analyze whether a logical drive requires defragmentation or not.

Click the following link if you want to download the MP or review the guide for more information, http://www.systemcentercentral.com/tabid/145/IndexId/64216/Default.aspx. The download will include a sealed copy of the MP, an unsealed copy of the MP and the MP guide.

I hope you find it useful and please let me have and feedback, good or bad, that you may have :-)

David

View DPM Protection Groups in Operations Manager

David Allen MVP — Tue, 02 Feb 2010 15:05:00 GMT

Ever wanted a centralised list of all your protection groups across all of your DPM servers? Well this guide I wrote explains how you can do just that in Operations Manager.

http://www.scdpmonline.org/view-dpm-protection-groups-in-operations-manager.aspx

David Allen
MVP System Center Operations Manager

http://www.scdpmonline.org
http://wmug.co.uk/blogs/aquilaweb

OpsMgr MP Authoring Survey

David Allen MVP — Tue, 19 Jan 2010 11:25:00 GMT

Do you want your voice to be heard and directly influence improvements and changes in MP Authoring? Well if you do, complete the MP Authoring Survey now !

http://www.surveymonkey.com/s/mpauthoring

It will only take 10 short minutes of your time.

Thank you.

David Allen
MVP System Center Operations Manager

http://www.scdpmonline.org
http://wmug.co.uk/blogs/aquilaweb