Tuesday, March 31, 2009

For a while now, I've been planning on getting my hands dirty using PowerShell. There are at least four features that make this a pretty compelling scripting environment:

The ability to write scripts combining regular scripting commands with the full power of the .net base class library (also including Cmdlets that you implement youself).

The ability to easily define functions as a part of the script.

The Cmdlet Verb-Noun naming convention, giving the scripting syntax a consistent and easy to discover feel that is completely missing in the jungle of cryptic abbreviated commands of the scripting environments of yore.

Everything is object based, so that when you, for instance, loop through all files in a directory by using the built in Get-ChildItem function, you are in fact accessing objects that represent the files and not just a textual path.

I hereby announce that I have completed my first PowerShell script (see below).

The good thing about being a latecomer is that you get to use the newest version, so I went directly for PowerShell 2.0 CTP3. A very nice thing about this version is that it comes complete with its own Integrated Scripting Environment, and this has been tremendously helpful in the process of understanding the basics and weeding out bugs.

So, what does my very first PowerShell script do? It recursively copies the contents of one directory to another one. As input to this process it takes a list of directory matching filters and a similar list of file extensions to be used as a filter. All in all this serves the purpose of copying the entire contents of a directory will keeping away from certain paths and files as dictated by the filters.

So by giving in this: "_ReSharper","\obj","\bin", "\.svn" as directory filter and this: ".user", ".suo", ".resharper" as file extension filter, I get functionality for copying .NET source code directories without also copying all the crud that is lying around as a by-product of the VS build process, SubVersion, ReSharper and so on.

I guess that everyone with some PowerShell experience will view this script as childishly amateurish, but at least it works .

Earlier I discussed the time-out problem which was a serious setback to the plan of building a client side change gathering infrastructure based on System.Transactions. How did we fix this problem? Well, we didn't. Instead we had to resort to cheating:

The above code shows how we now start client side transactions. As you can see, we no longer start a System.Transactions.TransactionScope, but rather look up a factory class (ITransactionScopeFactory) through a service locator, and ask this instance to start a transaction scope. This scope implements the interface ITransactionScope which is defined as follows:

/// <summary>/// A scope mimicking the API of System.Transactions.TransactionScope./// Defines a single method Complete() used for marking the scope/// as "successful". This interface extends IDisposable, and when/// Dispose() is invoked, this scope will instruct the ambient/// transaction to commit or rollback depending on whether the /// scope has been completed or not./// </summary>public interface ITransactionScope : IDisposable{ /// <summary> /// Marks the scope as complete, resulting in this scope /// instructing the ambient transaction to commit when /// Dispose() is invoked later on. If Complete() is never /// invoked, the scope will force the ambient transaction /// to rollback upon Dispose(). /// </summary> void Complete();}

The responsibility of the factory is to determine the type of scope to generate, and this it does by querying the ambient transaction as to whether or not a transaction already has been started. If such a transaction does not exist an instance of ClientTransactionScope is created, and if a transaction already exists, an instance of NestedClientTransactionScope is created. The difference between these two classes lie mainly in their respective constructors and in the Dispose() method:

Constructor and Dispose() of ClientTransactionScope

/// <summary>/// Initializes a new instance of the <see cref="ClientTransactionScope"/> class./// The ambient transaction is automatically started as this instance constructs./// </summary>public ClientTransactionScope(){ GetClientTransaction().Begin();}

Constructor and Dispose() of NestedClientTransactionScope

/// <summary>/// Initializes a new instance of the <see cref="NestedClientTransactionScope"/> class./// This constructor does nothing since an ambient transaction already has been/// started if an instance /// </summary>public NestedClientTransactionScope(){}

/// <summary>/// If Complete() has been invoked prior to this, nothing happens/// here. If Complete() has not been invoked, the ambient transaction/// will be marked as "non commitable". This has ne immediate /// consequence, but the transaction is doomed and it will be/// rollback when the outermost scope is disposed regardless of/// if this scope attempts to rollback or commit the tx./// </summary>public override void Dispose(){ if (!Completed) { GetClientTransaction().MarkInnerTransactionNotCompleted(); }}

The comments in the code explain the distinction between these two classes.

Commit and Rollback

The actual task of finishing the transaction, either by commit or rollback, is the responsibility of the ambient transaction. Throughout the lifetime of the scope, enlistments that have detected changes have enlisted with the ambient transaction. The exact details of how this enlistment procedure is done is kept hidden from the enlistments, but what actually happens is that the ambient transaction maintains a dictionary in which the enlistments are added.

When the time to commit or roll back has finally arrived, a real System.Transactions.TransactionScope is started, the registered enlistments are enlisted with the transaction, and Complete() is either invoked or not on the scope depending on whether or not the transaction is meant to be committed or rolled back:

/// <summary>/// Instructs the transaction to begin the two-phased commit procedure./// This will be done except if any nested inner transaction scope/// have instructed the transaction to rollback prior to this. If this/// is the case the transaction will roll back the transaction at this/// point in time./// </summary>public void Commit(){ if (!canCommit) { Rollback(); throw new TransactionAbortedException("Inner scope not completed"); } using (var scope = new TransactionScope()) { EnlistAll(); scope.Complete(); }}

/// <summary>/// Instructs the transaction to rollback. This will happen at/// once if the sending scope is the outer scope (fromInnerScope == true)/// else the rollback will be postponed until when the outer scope/// requests a commit/// </summary>public void Rollback(){ using (new TransactionScope()) { EnlistAll(); // Don't Complete the scope, // resulting in a rollback }}

Conclusion

This concludes this series which has been an attempt at showing the benefits and problems that we have seen when realizing a novel idea: using the functionality of System.Transactions as a "change gathering infrastructure". The idea has proved viable, however the "timeout problem" proved to be a serious bump in the road, and forced us to implement code so that the actual functionality of System.Transactions only comes into play in the final moments of the logical scope.

About Me

Ståle has over 15 years of experience as a programmer/architect, helping to build "enterprise sized" solutions for customers. He works for Computas AS, based just outside of Oslo, Norway.
In a previous life he enjoyed expressing himself with Lisp, but now he mainly concentrates on .NET with some forays into the beautiful world of Smalltalk.