instantiate

System Center Operations Manager Powershell Modules - An Error Handling Strategy

Luke — Wed, 02 Nov 2011 14:59:00 +2200

Lately I've been involved with SCOM 2007 R2 custom management pack development. We have been using quite a lot of powershell, primarily using the Microsoft.Windows.PowerShellPropertyBagProbe. Today I noticed however that sometimes if a powershell script fails in a workflow, SCOM silently swallows the output to the error pipeline and continues. No 22406 "The PowerShell script failed with the below exception" events in the Operations Manager event log, nothing.

As we want to know if our powershell scripts fail, it seems prudent that we should implement our own error handling and logging. The following script template provides base logging functionality, logging to the Operations Manager event log via the SCOM COM ScriptAPI. The two provided parameters $logErrors and $logDebug can be set as overridable in the workflow, allowing operator customisation of the level of logging.

param([int]$logErrors, [int]$logDebug) $Script:scriptname = $MyInvocation.MyCommand.Name; $Script:api = New-Object -comObject 'MOM.ScriptAPI' $Script:bag = $api.CreatePropertyBag() function LogError([string] $msg) { if($logErrors) { Write-Host $msg; $Script:api.LogScriptEvent($Script:scriptname, 100, 1, $msg); } } function LogInformation([string] $msg) { if($logDebug) { Write-Host $msg; $Script:api.LogScriptEvent($Script:scriptname, 101, 4, $msg); } } #Your Script here trap [SystemException] { LogError($_.Exception.ToString()); continue; } $Script:bag

Monitoring the monitoring!
From here it is fairly straight forward to create a rule or monitor workflow that detects the events from the event log and alerts on the health of all powershell scripts running in monitoring workflows.

Creating a XAML Windows Phone style loading animation

Luke — Wed, 24 Aug 2011 16:10:00 +2200

I've been doing more and more XAML development lately, and have recently traded my iPhone for a Windows Phone. One WPF application that I've been working on has a Metro design feel to it but had a plain loading screen. I created an animation with 5 animated rectangles like the Windows Phone loading animation, which was surprisingly easy.

I created the animation on a Rectangle element using blend, I used keyframes as the animation changes speed as it moves across the screen. The resulting XAML was:

The DoubleAnimationUsingKeyFrames allows you to specify where the element will be in pixels at a given time. It then smoothly animates the transition between these points, allowing for the changes in speed. This works for a fixed screen size of 1000px but a render transform like this can only take explicit values which isn't great if the size of the control can vary at runtime (fluid layout). We want our loading animation to fill the whole screen, not appear halfway across the middle! To work around this I added x:Name attributes to the animation KeyFrame elements so that I could refer to them in code (I know, not perfect) and set the width in the SizeChanged event of the parent control. This way if the parent control has its width explicitly set or if it defaults to filling its parent (in my case the WPF Window, in the case above the div container) then the animation will be relative.

/// <summary> /// Manually set the values for the animation when the window size is changed so the /// rectangle is animated across the whole screen. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void LoadingRectangle_SizeChanged(object sender, SizeChangedEventArgs e) { if (e.WidthChanged) { KeyFrame2.Value = this.ActualWidth / 3; KeyFrame3.Value = KeyFrame2.Value * 2; KeyFrame4.Value = this.ActualWidth + 10; KeyFrame5.Value = this.ActualWidth + 10; } }

Finally I added a property for delay in seconds, so that many of these controls can be used together and triggered at the same time, but appear slightly staggered - Windows Phone 7 has five rectangles that animate one after the other.

/// <summary> /// The number of seconds from the control being loaded that the animation should   /// be offset. This defaults to zero, meaning the animation will start as soon as   /// the control is loaded. /// </summary> public double OffsetSeconds {  get { return this.OffsetSecondsValue; } set { this.OffsetSecondsValue = value;  this.OffsetKeyFrameKeyTimes();  }  } /// <summary>  /// Offsets the four keyframes of the animation with the set offset value. This /// allows rectangles to be visually staggered if more than one are being used together.  /// </summary>  private void OffsetKeyFrameKeyTimes()  { TimeSpan offset = TimeSpan.FromSeconds(OffsetSeconds); KeyFrame1.KeyTime = KeyFrame1.KeyTime.TimeSpan.Add(offset); KeyFrame2.KeyTime = KeyFrame2.KeyTime.TimeSpan.Add(offset); KeyFrame3.KeyTime = KeyFrame3.KeyTime.TimeSpan.Add(offset); KeyFrame4.KeyTime = KeyFrame4.KeyTime.TimeSpan.Add(offset); }

The final XAML to have five rectangles working together looks like this:

<LoadingRectangle OffsetSeconds="0.0" /> <LoadingRectangle OffsetSeconds="0.2" /> <LoadingRectangle OffsetSeconds="0.4" /> <LoadingRectangle OffsetSeconds="0.6" /> <LoadingRectangle OffsetSeconds="0.8" />

Moving on to the UK

Luke — Tue, 03 May 2011 11:18:00 +2200

I've left Intergen Wellington to pursue personal and professional growth overseas. It's not easy leaving a place that feels like home, with a staff that feel like family. I'm incredibly greatful for the time I've spent with Intergen, they are an amazing company. I hope I will see them again in the future :-)

I'm currently in Singapore en-route for the UK where I will be looking for a .NET role. In the mean time posts to this blog will be irregular, but you can follow my travels at journeys.instantiate.co.nz.

Demoware vs Enterprise Applications

Luke — Mon, 28 Mar 2011 02:14:00 +2200

During my typical commute earlier in the week I was browsing through my RSS feed as I often do. I stumbled upon this post about Code First Entity Framework 4 development. Great I thought, this sounds good. I wonder if Code First will be a good choice for my next project. Unfortunately rather than the useful post about the details of the new Code First EF features I was looking for, I got demoware 101: how to build something rubbish really quickly!

This got me wondering if Microsoft do provide any guidance around building enterprise scale applications. I was pleasantly surprised to find the .NET Application Architecture Guide on the patterns and practices codeplex site. It's not a quick read but so far I'm really enjoying it and recommend reading it. You can get it here from MSDN as a free PDF download.

Writing Entity Framework queries using LINQPad

Luke — Fri, 18 Mar 2011 02:32:00 +2200

I've been doing a bit of query tuning lately and have been introduced to LINQPad which makes writing and tuning LINQ queries easy.

In this example I use the good old AdventureWorks database. I have an entity framework data access method that returns Customers for an email address

/// <summary> /// Gets the customers with the given email address /// </summary> /// <param name="emailAddress">The email address.</param> /// <returns>A list of customers</returns> public IList<Customer> GetCustomers(string emailAddress) { using (var connection = new AdventureWorksLT2008Entities()) { return connection.Customer.Where(c => c.EmailAddress == emailAddress).ToList(); } }

A fast way to figure out the sql that this query is executing is to fire up LINQPad and point it at the assembly with the Entity Framework data model (EDMX) file in it. If we add a connection, we can choose to add a typed data context from our own assembly

Once we point it at our assembly, LINQ pad detects that we have an EF data context and fills in the rest of the details from the default connection string used by the EDMX (in the assembly config file, which by default is copied to the output directory).

We now get a tree view of the various entity collections in our data context. We can copy our query into the query window, make a few tweaks like in-lining parameters with example values and execute our query against the database. LINQPad displays the results in a nice table view by default.

If we click on the SQL tab we can see the SQL that the EF engine has generated, from where we can copy it into SSMS or a similar tool to interrogate the execution plan and determine if it will perform well. This also allows you to play around with different ways of writing LINQ queries to find the method that generates the best SQL while returning the data you need.

It's a bit of a trivial example but shows a real world approach to query development using Entity Framework. The ORM may abstract you from writing SQL but the way your queries are executed by the SQL engine is as important as ever!

Contract first vs Code first WCF

Luke — Sat, 26 Feb 2011 08:24:00 +2200

It's a bit of an aging debate but I thought I'd share my two cents regarding contract first WCF development seeing as I've been using it on a project for a while now.

Writing XSD markup is painful.
Put simply, it's my opinion that if you don't have to, don't do it! Sure, like anything once you get used to it you get fast at it. That doesn't mean you should be spending your time doing it, particularly when WCF can do it for you. Tools that validate and visualise xsd files for you as you write them help, like Altova's XMLSpy. The ability to look at a tree representation of your contract graph as you write the XSD is really useful. Plus it's a great way to start off your documentation around consuming the services, if you're writing services for public consumption.

Pretty XML schemas help people who consume your service.
Having a readable XSD with comments and annotation that is all contained in one file has got to be helpful for the developers consuming your service. It's pretty easy to use a WCF behaviour extension to serve up a static WSDL that links that XSD file you spent so long hand crafting. We published draft XSD files well ahead of implementation to give the consumers of our service an indication of the operations and types we were planning in the near future, contract first made this easier.

Pretty XML schemas != pretty contract code
There is a tradeoff between clean XML schemas, and clean contract code. You need to constantly consider what is best in each situation. I recently had a situation where I had two operations that contained different elements with the same sequence of inner elements. It was tidier in the XSD to declare this as two different elements with different names, of the same type. The issue with this however was that in code I wanted two contract types as these objects needed to be treated differently. You can use composition, inheritance or repetition in the XSD to achieve this - none of which are optimal!

Would I do it again?
If I were publishing a public or externally consumed endpoint, yes. For services within an organisation or that are part of an application and not for external consumption? Nope!

Using the Windows timezone for Enterprise Library logging formatters.

Luke — Mon, 25 Oct 2010 23:36:00 +2200

By default entlib uses GMT time for timestamps. If you're in New Zealand this means the timestamps on your log entries are all incorrect. This is something that I always forget how to do but it is very easy to correct. If you have a text formatter that looks similar to:

<formatters> <add template="Timestamp: {timestamp}
 Message: {message}
 Category: {category}
)}" type="Microsoft.Practices.EnterpriseLibrary.Logging.Formatters.TextFormatter, Microsoft.Practices.EnterpriseLibrary.Logging, Version=3.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" name="Text Formatter" /> </formatters>

You simply need to change the {timestamp} to {timestamp(local)} and it will use the server timezone. Easy.

Regular expressions with MSBuild. Reading version numbers from AssemblyInfo.cs

Luke — Mon, 04 Oct 2010 01:40:00 +2200

I'm a huge fan of continuous integration and automated builds. I've written about MSBuild before and find myself using it a lot; mainly because it's familiar and build scripts aren't the sort of thing you have a lot of time to spend on. I've used MSBuild to increment version numbers before, every build having a different number is a good idea (MSDN, 2010). Previously I have written the build number that gets incremented into a text file containing only the number, so it is nice and easy to fetch.

Recently though I wanted to read the version (Major.Minor.Build.Revision) numbers from the assemblyInfo file into properties in my build script, so I could modify and use them as required. What follows is an MSBuild target that uses the MSBuild Community Tasks RegexMatch and RegexReplace tasks to do just that.

<ReadLinesFromFile File="$(VersionInfoFile)"> <Output TaskParameter="Lines" ItemName="IterationNumberFileContents"/> </ReadLinesFromFile>

First we read all the lines from the versionInfoFile into a task item. I have a file that contains just the solution version with the other solution info properties in another file. This will work if this is a full solution info file though.

<RegexMatch Input="@(IterationNumberFileContents)" Expression="AssemblyVersion\(\"(\d+)\.(\d+)\.(\d+)\.(\d+)"> <Output ItemName="VersionNumberLineReturn" TaskParameter="Output"/> </RegexMatch>

Next we use the RegexMatch task to find the string AssemblyVersion("X.X.X.X in the file (X's being any number). Note that we escape the parenthesis and quotes with a backslash as these have meaning in regular expressions. We wrap each digit selector in parenthesis (\d+) so that we can refer to it as a regular expression group. The .NET regular expression engine allows you to reference parts of the selection using back references (Goyvaerts, 2010). $0 represents the entire string matched (in our case AssemblyVersion("X.X.X.X ). $1 - $9 represent groups in the order they were matched. In our case $1 through - $4 represent the four version numbers.

<RegexReplace Input="@(VersionNumberLineReturn)" Expression="\[assembly\: (AssemblyVersion)$\"(\d+)\.(\d+)\.(\d+)\.(\d+)\$(DOUBLE_QUOTES)$\]" Replacement="$1" Count="1"><Output PropertyName="MajorNumber" TaskParameter="Output"/> </RegexReplace>

This makes it easy to select out each version number into a property using these back references and the same regular expression. Above we are selecting the major version into the $(MajorVersion) property. I'm sure there is a more elegant way to do this than repeating the regular expression, but I don't know how to specify multiple outputs from the regexMatch/regexReplace tasks.

The full target which selects all four version numbers into properties is available to download here (2.00 kb), I hope this saves you some time.

References:

Goyvaerts, Jan. (2010). Replacement text reference. http://www.regular-expressions.info/refreplace.html

MSDN. (2010). Assembly Versioning. http://msdn.microsoft.com/en-us/library/51ket42z%28v=VS.100%29.aspx

The template method pattern: processing WCF requests

Luke — Thu, 23 Sep 2010 06:57:00 +2200

Im working on a project at the moment building a message bus using WCF. We have a submit data method that takes a number of different message types; create widget, update widget etc. We need to process these requests quite differently based on the type of message passed in but there is some commonality to the processing for all message types.

The template method pattern was really useful here, we have a base message processor that contains the common processing steps and provides a "hook" method that specific message processor sub classes can override. This base class takes care of common logic for us like storing the message payload for audit and saving any results from processing. The code looks like this:

public abstract MessageProcessorBase<TMessage> { public void ProcessMessage(TMessage message) { StoreMessage(message); ProcessingResults results = ProcessMessageByType(); SaveProcessingResults(results); } protected abstract ProcessingResults ProcessMessageByType(); private void StoreMessage(TMessage) { ... { private void SaveProcessingResults(ProcessingResults results) { ... } }

All of these methods are private on the MessageProcessorBase except the ProceessMessageByType which is abstract and overridden in the subtypes. Now for each message type we simply create a message processor and implement the specific processing logic.

The message processor base is generic meaning it can be strongly typed to each specific message type, while not being tied to any one message type. The nice thing about this is that we have a strongly typed message processor for each message type.

That's all there is to it, a tidy way of using inheritence to make our message processor class closed to change but open to extension.

AUT University What I Wanna Be Video

Luke — Sun, 05 Sep 2010 23:38:00 +2200

I was recently asked to feature in an AUT University television promo on MTV New Zealand. 'What I Wanna Be' is a series of short videos each featuring an AUT graduate and focusing on what they are doing now. I was honoured to be selected to appear in the video. It has been airing on MTV for a week or so but is attached below if you'd like to watch it.

The video was a lot of fun to make, the MTV crew were awesome. You can win a Macbook by answering a few questions about it on the MTV website.