VSoft Technologies Blogs

EC2 Support in FinalBuilder 7.0

Sun, 04 Sep 2011 14:00:00 GMT

FinalBuilder 7.0.0.1497 adds support for Amazon's EC2 Cloud Services. The EC2 Actions allow you to interact with EC2 instances during your build process. This enables deploying to test or production environments running on EC2 services.

The EC2 support add's 16 new Actions to FinalBuilder :

EC2 Get Instance Properties - This action allows you to retrieve the selected property of instances available to you. You can filter which results to return using the optional filters.

EC2 Change Instance States - This action enables you to change the state of one or more instances.

EC2 Run Instances - This action enables you to run (create) one or more instances.

EC2 Terminate Instance - This action enables you to terminate one or more instances. Note that this action is permanent and cannot be undone.

EC2 Get Image Properties - This action allows you to retrieve the selected property of images available to you. You can filter which results to return using the optional filters.

EC2 Create Image - This action enables you to create an image from an instance.

EC2 Deregister Image - This action enables you to deregister (delete) an image. Please note that this action is permanent and cannot be undone.

EC2 Create Volume - This action enables you to create a volume, either as a blank volume of a specific size, or a volume restored from a snapshot.

EC2 Delete Volume - This action enables you to delete a volume. Note that this action is permanent and cannot be undone.

EC2 Attach Volume - This action enables you to attach a volume to an instance.

EC2 Detatch Volume - This action enables you to detach a volume from any instances it is attached to.

EC2 Get Volume Properties - This action allows you to retrieve the selected property of volumes available to you. You can filter which results to return using the optional filters.

EC2 Get Snapshot Properties - This action allows you to retrieve the selected property of snapshots available to you. You can filter which results to return using the optional filters.

EC2 Create Snapshot - The Access Key and Secret Key for your AWS account. If "Use Global Values" is checked, the values set in the options page (Tools > Options > Internet > EC2) will be used instead.

EC2 Delete Snapshot - This action enables you to delete a snaphot. Note that this action is permanent and cannot be undone.

EC2 Get Availability Zones - This action allows you to retrieve the name of availability zones available to you. You can filter which results to return using the optional filters.

FinalBuilder: now with NuGet-y goodness

Fri, 27 May 2011 08:12:00 GMT

NuGet is a open source package management tool for .NET applications. It allows you to very simply install, create and share reusable assemblies. With the latest release, FinalBuilder now contains a set of actions to help you interact with NuGet as part of your automated build process.

First things first

To get started, you'll need to download nuget.exe from codeplex. Optionally, if you'd like to Push or Delete to nuget.org you will need an APIKey. You can get one by creating an account at nuget.org and going to the My Account page.

Once you have those, in FinalBuilder go to Tools -> Options and under .Net Tools select NuGet. Set the path to the folder where nuget.exe is located and if you have an API Key, add it in as well.

Installing packages

If you use nHibernate, jQuery or any of the 1500 other packages that are available from nuget.org, you can use the NuGet Install action to keep your build process up to date. This is particularly useful if you're using FinalBuilder on a continious integration server such as FinalBuilder Server.

You can install from the default (nuget.org) server or your own custom package feed. Having your CI server pull down the latest version of a third party library is a quick and easy way to see if the latest version has any breaking changes for your codebase. If it does, you can choose to install a specific version until you've modified your code to be compatable with the changes.

Sharing packages

If you develop an open source library for .NET and want people to use it, it makes a lot of sense to have it published on NuGet. And if you use FinalBuilder to build the library, it's pretty simple to add publishing into your build process. Or, if you have a lot of shared internal assemblies and are looking for a better way to distribute them, publishing to an internal NuGet server may make your life a lot easier.

FinalBuilder has 4 actions to help with the publishing process. If you're familiar with using nuget.exe from the command line they should be very familiar.

The Spec action creates a .nuspec file - either with placeholder data or with metadata from a project file (.csproj) or an assembly. The nuspec is an XML file, so after you've created it you can use FinalBuilder's XML actions to easily manipulate it.

The Pack action creates a .nupgk file from your nuspec, ready for deployment. Alternatively, you can create a package directly from a project file. The Pack action lets you choose which project configuration to use (if you're using a csproj), override the version number and use a pattern to exclude files from the package.

Once you have your nupkg, you can use the Push action to publish it to either the default server on nuget.org, or to your custom NuGet server. If you prefer, you can upload but not publish the package. That way you can manually go to the site and press the Go button before anyone will see it.

Lastly there's the Delete action, which removes the package you specify from the server.

Further information

NuGet.org is the place to go any lots more information. Scott Hanselman also has an excellent presentation that covers everything you should need to know (although we disagree with his choice of build automation tools :) )

FinalBuilder Master Class - Part 1 - Hidden features.

Tue, 26 Apr 2011 14:00:00 GMT

Over the next few posts, I'm going to try to talk about some of the lesser known features in FinalBuilder, and show some ideas and techniques that I hope will help you improve your FinalBuilder projects.

Wouldn't it be great if a failed action could automatically retry if it fails?

Absolutely, it's a great idea, and its a feature that's been in FinalBuilder for several years. Unfortunately it's not as obvious as it could be, we ran out of screen real estate a few versions back and it got pushed into another dialog (rather than add another tab!)

Note that this feature should really only be used when accessing a resource which might occasionally fail, for example we use this on our SignTool action when codesigning/timestamping the exe's because the timestamp server (Verisign's) sometimes fails to respond. We found if we ran the build again straight away, the timestamp server usually responds just fine, the server availability issue is usually transient and the retry option with a suitable pause resolves this issue nicely. It makes no sense to use this option on a compiler action though, as the result would most likely not change.

I wish I could define local Variables!

In FinalBuilder 7, you can! The Action Group action in FB7 allows you to define local variables. These variables are then available to all child actions of the Action Group action.

How can I capture and process the output of my custom executable?

We get ask this one quite often, so I guess we haven't done a great job of publicising the Output Monitors feature. Output Monitors are available on all actions, and they allow you to process the logged output of the action. A typical example of the use of output monitors might be to fail an action if a particular bit of text is output from the action.

Variable Suggestion (F12)

This is another one of those features that has been there a while but is not well known. I showed this feature to some of the newer developers here last week and got lots of "oh wow, I never knew that" type responses. I have to admit I'd forgotten about it myself until I started looking for ideas for this post! The way it works is that pressing F12 on a text field will drop down a list of suggestions on variable usage. The list is weighted so that variables that replace the most of the original string will list at the top. This is a great help in making sure you don't hard code paths when the project needs to run on another machine.

DUnit and FinalBuilder/FinalBuilder Server - better integration.

Sun, 14 Nov 2010 14:00:00 GMT

FinalBuilder has had an NUnit action for some time now, but for DUnit we have always advocated just compiling the unit test executable as a console app using the TextTestRunner, and using the Execute Program action. This has worked fine, however it doesn't provide the same sort of integration into FinalBuilder Server as the NUnit action provides.

FinalBuilder 7.0.0.848 or later includes a new DUnit action. This action is designed to run DUnit test applications that are written as console apps, and use the FinalBuilder.XMLTestRunner.pas file to run the unit tests. This unit produces and xml report file in the same format as NUnit, which means that FinalBuilder already knows how to parse it. Also included in the FinalBuilder\DUnit folder is an XSL stylesheet and a CSS file to transform the xml report file to html (which can be done using the TransformXML action. The FinalBuilder.XMLTestRunner is a combination of the xml test runner and the text test runner. It still writes out to the console (which the action sends to the FinalBuilder log) and it also writes the xml report file.

When the DUnit action is used under FinaBuilder Server 7.x - the DUnit results are shown on the Status page :

and in a separate tab on the Build Log page :

The Passes and Failures can be inspected by clicking on the green or red buttons.

The FinalBuilder\DUnit folder also includes a simple example test application which shows how to structure your test executable to use the FinalBuilder.XMLTestRunner.

FinalBuilder 7.0.0.848 is available here - disclaimer - please note it is a Test build, which means it's a build which contains bug fixes and or new features since the last official update, but has not had the same testing applied to it as an official update build would.

Introducing FinalBuilder 7

Sun, 11 Jul 2010 14:00:00 GMT

It's been a long time in the making, but FinalBuilder 7 is almost here. FinalBuilder 7 has been in private beta testing for a few weeks, and today we are opening the beta to existing customers.

If you have an account on our website, and have a license for any version of FinalBuilder then you should have access to the FinalBuilder 7 Beta Forum. If you don't see it, try logging out and in again.

What's new in FinalBuilder 7?

NEW IDE

Well, as the saying goes, a picture is worth a thousand words.. so lets take a look :

FinalBuilder 7 sports a new IDE. The FinalBuilder 7 IDE is capable of opening multiple projects (whereas FB6 only allows 1 at a time). The new IDE includes docking, something that has been requested many times over the years, so you can lay out the IDE to suite your taste. The current theme is modelled on Visual Studio, however by the time FB7 ships we should have an alternative theme available too.

There are many little enhancements and tweaks in the IDE. The most requested feature that we did implement is the renaming of variables. In FB6, when you rename a variable it does not rename references to it in the project. FB7 will attempt to find and rename all references (there may be a few cases we have missed, if you find any let us know).

Core Changes

Unicode Support

FinalBuilder is now compiled with a unicode aware compiler. The native internal string type is UTF16, and we have worked hard to ensure that all actions that work with files respect the original files encoding. This has been a massive endevour, and we are still in the process of testing actions to ensure compliance. The user interface should fully support unicode. Note that while FinalBuilder may support unicode, many of the tools it calls do not.

Variable Types

In FinalBuilder 6 and earlier, all FinalBuilder variables are implemented as Variants. Those of you who have done some COM programming, or used Visual Basic 6 or earlier, or Delphi might be familiar with Variants. A Variant is a type that can store values of various types. Variants are very useful in many cases, but are not without their problems. For example, if you want to store a string "03" in a variant, you will have to put the double quotes around the 03, otherwise we have no idea it's not a number. To circumvent this problem, in FinalBuilder 7 we allow you to specify the variable type :

When you specify a variable type, that is how the variable will be treated, so for example if you attempt to assign a string value to an integer variable it will fail. Typed variables also allow you to specify a format string, which will be used when the variable is evaluated in an expression. For example, if you have a build number variable, that you always want to use as 4 digits, with zeros padding out the left, setting the format string to %.4d will do this.

Local Variables

In addition to the existing variable scopes (environment, application,user, project) and action list parameters, FinalBuilder 7 includes a local variable scope. The Action Group Action has a new property page that allows you to define the local variables.

These variables are only visible to child actions of the group. Since groups can be nested, this provides the ability to override variables locally, and define variables for temporary use.

Local variables cannot be persisted and cannot be used as environment variables.

New Actions

Of course as with every new release we added a bunch of actions:

- NDepend Action
- Git Actions
- Plastic SCM Actions
- Check If Host Exists Action
- SetupBuilder Actions
- SecureZIP Actions
- Signtool Actions
- Hyper V Actions
- Mercurial Actions
- SSH Actions
- XML Node Exists Action

And many of the existing actions had enhancements to them, support for filesets added to more actions.

What about FinalBuilder Server 7?

The FinalBuilder Server 7 beta will be ready in a day or two. It's currently being used to build FB7 (FB7 is built using FB7 and FB Server 7).

What now

FinalBuilder 7 is feature complete for the 7.0 release, there are still many more features we would like to implement in updates. Right now we are in Test/Bug fix mode, that is all the team are working on. So now it's time for some feedback.. let us know what you think, and more importantly, if you find something that isn't working right then let us know. Please keep all beta bug reports and feeback to the FinalBuilder 7 Beta Forum. If you don't see the Beta forum and you are a customer please contact support at finalbuilder dot com and we'll grant you access.

FinalBuilder Roadmap for 2010

Mon, 14 Dec 2009 14:00:00 GMT

We don't usually have a published roadmap. I generally don't like to talk too much about the next version until I have something to show (ie when we are close to beta), however it's been a while since we release FB6 and some customers have asked what our plans are.

I will say that FinalBuilder and FinalBuilder Server are being actively worked on. Below is just a general outline of what we are up to :

FinalBuilder 7.0:

1) Full Unicode support. This is something that we have been working on for the last year. It meant finding replacements for many libraries and components we use, the biggest of which was the Active Scripting support. We ended up having to write our own active scripting library as the old one was impossible to move forward with (the vendor has long since disappeared). This work is mostly completed.

2) A new IDE - with the ability to open multiple projects, and hopefully be able to step into included projects. This required some major re-architecting of the core and the IDE and that is something we are still working on.

3) General enhancements to existing actions and some new actions. As usual, we have a long todo list to keep us busy.

FinalBuilder Server 7.0

FinalBuilder Server 7.0 will be a revision of the FBServer 6.0 code base. (Note that this has changed from my forum post in Nov. due to resourcing issues).

1) Support for more version control triggers. MKS, Clearcase and possibly Git have been identified as popular targets.

2) Enhancements to the user interface.. cleaning up html, more use of client side script to reduce postbacks.

3) Performance enhancements where possible.

We will also be looking at feature requests to see what else we can implement, but many will be implemented in a future product (see below).

FinalBuilder Server vNext + 1

Along side the developement of FinalBuilder, we have had another project running over the last year that was intended to be FinalBuilder Server 7. Due to a lack of resources (or more to the point, a lack of success in recruiting) we had to rethink our plans for this product. It's a large project, and it became clear over the last few weeks that it was not going to be ready to release alongside FinalBuilder 7. This project was born out of the feature requests and feedback from users, and an in depth look at what people were really asking for and why, as well as our own future needs (we are our own best customer!). It was clear quite early on that the architecture of FinalBuilder Server was not capable of supporting some of the features, and neither was ASP.NET.

So we started fresh. FB Server vNext (actual product name yet to be decided) was designed from outset to support work flow, build agents (possibly also on other platforms), tight integration with bug tracking systems and version control. We are also focusing more on the release management side of things.. management of build artifacts, release notes, tracking which issues are related to which builds, which checkins are related to which builds etc.

When???

Now what you are probably wanting to hear is when will the next versions be released. I'm not going to make any promises here, but we are aiming for FinalBuilder 7 and FBServer 7 at the end of Q1 next year. FinalBuilder Server vNext will come later in the year.

The biggest blocking issue for us at the moment is a lack of manpower (or woman power!). We are finding it hard to recruit suitable people. Canberra is a difficult place to run a software business, we have to compete with the many (both federal and ACT) government departments for people... and despite the election promises the government has only gotten larger over the last 2 years. We will continue our recruitment drive in the new year (but feel free to submit your resume - if you have the right to work and live in Australia).

Team Foundation Build and FinalBuilder

Tue, 02 Dec 2008 14:00:00 GMT

The Accentient Blog provided an interesting post recently comparing Team Foundation Build and FinalBuilder. It was great to see them offer an unbiased insight in to the distinctive advantages of each of these tools and it's worth a read if you're using or planning to use one or both.

We've had plenty to say over the years about the relationship between FinalBuilder and TFS/MSBuild/Team Foundation Build. Naturally, we have a slight bias toward one of the tools, but if you're interested in learning more about combining the two, check out:

how to integrate FinalBuilder with TFS;
why you would use FinalBuilder when you already have Team System;
why FinalBuilder and Team Foundation Build are a match made in heaven;
a comparison between the MSBuild community's wish list and the feature set of FinalBuilder; and
the benefits of using both FinalBuilder and TFS.

Finally, I must disagree with just one of Accentient's statments. The final line read:

As Team Foundation Build matures, it will likely provide a feature parity competitor to FinalBuilder, but it has some catching up to do.

As Team Foundation Build matures, it may begin to provide feature parity with FinalBuilder 5 or even 6. However, by then we'll be on to FB 7 or FB 8 and we have every intention of making sure these future versions will offer unique and useful features. Team Foundation Build will always have some catching up to do with FinalBuilder.

Using Python in FinalBuilder

Wed, 04 Jun 2008 14:00:00 GMT

Today FB 6.1 was released as a beta version. One of the major new features in this version is Python language support. We're leveraging Microsoft's IronPython project for this, and because version 2 of IronPython is built on the Dynamic Language Runtime, we're expecting that as other DLR languages become available, we'll be able to support them in FinalBuilder as well.

The Python language is pretty neat, and the fact that IronPython interacts seamlessly with the .NET Framework makes it pretty powerful by itself. It shares this feature with PowerShell.

However, what really makes Python awesome is the amount of extra library functionality that comes with the standard language distribution.

Example

This is a totally arbitrary example. Say your build process needs to calculate a SHA1 hash. FinalBuilder only supports MD5 at the moment. Can Python save the day?

Step One: Install Python Libraries

You need to install the Python standard libraries in order to get access to their many functions. You get this as part of the standard Windows Python distribution. Grab the "Windows Binary installer" from http://python.org/download/

Step Two: Tell FinalBuilder

You need to tell FinalBuilder where the Python library is installed. If you launch FinalBuilder and go to Tools -> Options -> FinalBuilder -> Script Options, as shown, you will see this options page:

Enter the path to the Python library directory, as shown here. The options page says you need to restart, but you actually only need to do this if you've run a Python script since you started FinalBuilder.

Step Three: Run Script Action

I use the Action filter to search for the all-purpose Run Script action, which I can then add to my project:

Step Four: Type in Script

Here's my SHA1 script code. I entered this in the OnExecute event, under the Script Editor tab at the bottom of the main FinalBuilder IDE. Make sure you set the script language to "Python", as shown:

Note that the FBVariables object behaves just like a normal Python dictionary.

Click here to download a sample project file.

Step Five: Run it!

Here's the log output from the SHA1 Run Script:

Where do I go from here?

This was a pretty basic example, but the Python library provides you with literally hundreds of similar pieces of functionality. Take a look at the Python Library Reference for a complete list.

Can't I just use the .NET Framework?

Yes! The .NET Framework also provides you with a wealth of built-in functionality. Using it from IronPython is pretty simple, too. Here's Python code that performs the same functionality, written to use the .NET Framework instead of the Python library:

(It's a bit more complicated, mostly because I couldn't find a neat .NET-based way to convert a byte array to a hexadecimal string. Note that this approach does not require the Python libraries, it will work out of the box with FinalBuilder.)

Both sample scripts are included in the downloadable example.

It would also be possible to rewrite the .NET version to use PowerShell, instead. I'll leave that as an exercise.

Hate Team Foundation Server?

Thu, 15 May 2008 14:00:00 GMT

According to Google Analytics statistics for the past month, a number of people found the FinalBuilder web site in Google search results for the query hate "Team Foundation Server"

I didn't know so many people felt that way!

(For the record, we think that FinalBuilder complements Team Foundation Build in very productive ways.)

FinalBuilder/Automise Keyboard Shortcuts

Tue, 15 Apr 2008 14:00:00 GMT

Brent was watching me fly through some FinalBuilder operations the other day and he suggested I write a blog post about the best keyboard shortcuts to use.

Even as a power user/developer, you can sometimes use a tool every day and not know the best keyboard shortcuts for it. I only learned many of the keyboard shortcuts for Visual Studio after I attended a special session at TechEd last year.

I don't want to drown you in information here, so I'm going to list four shortcuts that are essential to know, and another four that are very useful.

Essential

If you own a keyboard and use FinalBuilder or Automise, the following keyboard shortcuts are essential. They will improve your productivity ten-fold!

Key	Context	Description
Ctrl-I	Main IDE Window	Focus the Actions filter field to search for a new action. If the filter field is already focused, this keystroke hides the Actions sidebar instead.^*
Ctrl-Right	Selected action(s)	Indent the selected action(s) as new children of the action above them.
Ctrl-Left	Selected action(s)	Outdent the select action(s) relative to their parent action
Ctrl-Up/Down	Selected action(s)	Move selected action(s) up and down

In my opinion, using the Ctrl-Arrow keys to rearrange actions is essential (drag and drop is just too fiddly!)

^* The "hide sidebar if currently focused" feature is new in FB 6.

Very Useful

The following key combinations are very useful when you are typing in a text field while editing an action:

Key	Description
F3	Define a new variable on-the-fly.
F2	Pop up an advanced edit dialog with lists of variables, PropertySets, etc.
F12	Pop up a list of suggested variable replacements.
Ctrl-Space	Automatic completion for variable and PropertySet names.

For FB 6, we also did a lot of work on the Tabbing behaviour in the IDE. You should be able to use Tab to navigate the main IDE elements very easily.

Log output formatting in FinalBuilder 6

Thu, 03 Apr 2008 14:00:00 GMT

Introduction

In FinalBuilder 6, we have done a lot of work to improve the log output formatting. In particular, we wanted to make it easier to find errors, warnings in compiler output.

Output Grouping

Most compilers are quite verbose in their output, for example the Visual Studio action outputs reams text when using msbuild (the default for VS2005 and later). In the FinalBuilder 6 logging architecture, we add the ability to create Output groups. This allows us to structure the output in a manner that makes it much more readable, and they (as the name implies) allow us to group different parts of the action output. In the Visual Studio and MSBuild actions for example, we group the output but Project and Target :

Output Status Color Tagging

The output of most (if not all) actions in FinalBuilder 6 had been enhanced to use the new color tagging feature. When Error messages are generated, they are sent to the log with an error status, and the log displays the message in red. The screenshot below shows the message types and colors.

You can also use this tagging when using action script events and in custom actions. This is how it's done from a script event (in JavaScript) :

Action.SendLogMessage("This is Information message (the default).",stInformation)
Action.SendLogMessage("This is Success message.",stSuccess)
Action.SendLogMessage("This is a Warning message.",stWarning)
Action.SendLogMessage("This is an Error message.",stError)

FinalBuilder 6 - Output Monitors

Thu, 03 Apr 2008 14:00:00 GMT

Introduction

Output Monitors give you a quick way to watch action output and change the behaviour of the action depending on what you see. This lets you extend built-in actions in powerful ways.

Sample Project

Unlike my normal "pie in the sky" examples, this one is based on a real problem. This morning we had a customer in our chatroom who had a problem deploying to QA:

when a user's connection to the database breaks, or if a user is accessing some of the files in QA and connected to a different database (different to the one we are checking against) the FinalBuilder project will try and deploy the files and get a sharing violation which causes the build to fail

Summary: the customer needed a way to tell if one or more files were open on a remote machine.

SysInternals Tools Are Awesome

SysInternals make PsTools and a raft of other excellent Windows "power administrator tools". If you haven't checked them out, you should. It's no wonder that Microsoft bought the company.

For my solution to the above problem, I made use of two great SysInternals tools:

PsExec (part of PsTools) can deploy and run an executable on a remote machine. There's a PsExec action built into FinalBuilder, although you still need to download and install PsTools.
Handle is a great little command line tool that dumps (among other things) all of the open files on a system. An excellent debugging aid.

The Plan

Use PsExec to deploy and execute handle.exe on the remote computer, and use FinalBuilder to scan the output for the file(s) we need to check for.

The Project

Here's the complete project, including my verbose comments. Because of the powerful Output Monitor (and the awesome Sysinternals tools), almost everything happens inside the PsExec action:

Output Monitor

To check for our file(s), we need to configure an Output Monitor on the PsExec action. We have two variables:

fileName - The filespec or filename that we want to check for. This variable is set by the user.
fileInUse - The details of the file that's in use, if there is one. This variable is set when the PsExec action runs.

Every action in FinalBuilder 6 has an option on the Runtime tab called "Monitor Action Output":

Click the button to edit the Output Monitors for that action:

For our monitor (shown above), we're checking for any content which contains %fileName% and saving the first match to the variable fileInUse.

There are lots of other options for output monitor behaviour. Click on the dropdown for a full list:

... For example, if we wanted a list of all matching lines, we could use the "Save All Matches to Variable" behaviour.

As configured, the output monitor supports wildcard matching with * and ?. If we wanted it to be really powerful, we could change it to use a regular expression - grep-in-a-box!

Project File

You can download the FinalBuilder 6 project file here.

Alternatives

Sometimes you need more powerful output processing, and Output Monitors are not up to the task. You can always use the OnStatusMessage script event to run some script every time the action outputs data. I actually did a blog post about this a couple of weeks ago.

FinalBuilder 6 : PowerShell (Part Three, Custom Actions)

Wed, 02 Apr 2008 14:00:00 GMT

This is the last in a series of blog posts about PowerShell support in FinalBuilder 6.

Part One showed how to use one-liners to create powerful PowerShell execute conditions.
Part Two showed how to use PowerShell script events to parse output and change the behaviour of an action.

For this last post, I'm going to walk through creating a custom action which scans the Event Log and reports the frequency of messages from different sources.

The Script

Here are the parts of the PowerShell script that I'm going to use to implement the new action.

1) A custom function

WMI uses dmtf date formatting. This is a PowerShell function to create a dmtf datetime string representing (Now - $x hours) ago.

function dmtfWithin([int] $hours)
{
[System.Management.ManagementDateTimeconverter]::ToDmtfDateTime `
([DateTime]::Now.AddHours(- $hours))
}

2) Read Action Properties

Action properties are loaded using the same syntax as other custom actions. If you've used ActionStudio before then this will look familiar. Coming in-the-pipeline are some CmdLets to make this look more like PowerShell and less like .NET.

# Set up parameters
$computerName = $Context.ExpandExpression($Context.Properties.PropertyAsString("ComputerName"), $True)
$hours = $Context.Properties.PropertyAsString("Hours")

3) Process Event Log

This is where the dirty work happens - build a WQL filter string, get the WMI objects for the event log entries, and build a hashtable mapping event source names to their frequencies. The particularly neat line is the last one with the % sign - that's shorthand for "for each".

# Read results
$filter = "TimeWritten > '" + (dmtfWithin($hours)) + "'"
$results = Get-WmiObject -computer $computerName -class Win32_NTLogEvent -filter $filter
$freqTable = @{}
$results | % { $freqTable[$_.SourceName] += 1 }

4) Log the Results

Log the contents of our hash table, sorted and formatted into a table:

# Log Results
$freqTable.GetEnumerator() | sort -descending Value | ft Value, Name -autosize -wrap

5) Set Result to True

The Result parameter determines whether or not to fail the action.

$Result = $True

Creating the custom action

I recorded a screencast showing how to create the custom action in ActionStudio. Click here to view in a new window.

Running the custom action

Click here to view this screencast in a new window.

Download

Click here to download a zip file with the custom action package. The unzipped .fbap file needs to be saved in the ActionDefs directory inside the FinalBuilder 6 program directory.

More Resources

The example action package "FBScriptExamples.fbap" comes with FinalBuilder, and contains some more sample PowerShell actions which can be loaded in ActionStudio.

The ActionStudioManual.pdf file (located in the FinalBuilder Program directory) contains a reference section with built-in custom action types and methods, and also some more information on creating PowerShell actions.

Some Notes

This is a pretty simple example, but (like the others) it is fairly simple to extend it to cover lots of other Windows-related tasks.
FYI, there is a dedicated Get-EventLog command in PowerShell. In this instance, I chose to use WMI instead because WMI can read from remote machines, and can read across all event logs. If you use the dedicated command, you need to choose a single event log to read from.

FinalBuilder 6 : PowerShell (Part Two, Script Events)

Wed, 26 Mar 2008 05:00:00 GMT

PowerShell Script Events

This is Part Two in a series about the new PowerShell support in FinalBuilder 6. In Part One, we learned how to create an action Execute Condition using PowerShell.

In this article we will show how to use PowerShell as a scripting language in the FinalBuilder IDE, in order to customize the behaviour of a built-in FinalBuilder action. We'll also showcase some of the powerful string processing features in PowerShell.

Script Events

When you add an action to a FinalBuilder project, you also add at least three script events:

BeforeAction - This script event is called before the action runs.
OnStatusMessage - This script event is called each time the action outputs something to the log.
AfterAction - This script event is called after the action has finished running.

You can access the script events by clicking on the "Script Editor" tab in FinalBuilder. For this blog post, we're going to use PowerShell to create an implementation for each of these script events.

PsLogList

I'm going use scripting to extend the built-in FinalBuilder action for the PsLogList tool. PsLogList is part of the PsTools suite from SysInternals/Microsoft. It dumps the contents of the event log on a local or remote machine.

We're going to customize the action so it parses the list of log entries to automatically extract data about the frequency of events from different sources.

Output format

Here's an example log entry, as output from PsLogList:

[16664] Service Control Manager
Type: INFORMATION
Computer: DYNAMO
Time: 3/03/2008 3:09:18 PM ID: 7035
User: NT AUTHORITY\SYSTEM
The IMAPI CD-Burning COM Service service was successfully sent a start control.

For our example, the piece of data want to extract would be "Service Control Manager" in the expression above. To extract this, we can use the following Regular Expression:

^\[\d+\] (.+)$

Regular expressions are supported directly in PowerShell. You can create a regular expression using a code snippet like this:

$headerExpr = [regex] "\[\d+\] (.+)"

(If you ever need help remembering Regular Expression syntax, I recommend www.regular-expressions.info.)

Hash tables

The other piece of PowerShell functionality that we're going to make use of is the hash table. We're going to create an empty PowerShell hash table, and then use it as a dictionary to store event source names along with the frequency that each source appears.

Here's the script used to create a new empty hashtable:

$hashTable = ${}

To increment the frequency of an item in the table, we can use the increment operation += on the hashtable entry. If there is no entry, PowerShell returns $null, but ($null + 1) == 1 so it will work properly.

$hashTable[$name] += 1

Scripting it up

Here are the complete script events: (download as project.)

BeforeAction Script Event

# Create empty hash table for use in action (we need to store it in a Project Variable)
$FBVariables["FrequencyTable"] = @{ }

OnStatusMessage Script Event

# When output comes from the action, check if it is an Event header line

$headerPattern = "^\[\d+\] (.+)$"
$RegexOptions = [System.Text.RegularExpressions.RegexOptions]

foreach ( $match in [regex]::Matches( $StatusMessage.MessageText, $headerPattern, $RegexOptions::MultiLine ) )
{
$appName = $match.Groups[1].Value.Trim()
$freqTable = $FBVariables["FrequencyTable"]
$freqTable[$appName] += 1
}

AfterAction Script Event

# Log the frequencies, sorted by value
"Frequencies for different sources"
$FBVariables["FrequencyTable"].GetEnumerator() | sort -descending Value | ft Value, Name -autosize -wrap
#
# (the .GetEnumerator() call in the expression above is a trick which allows us to sort the contents of the hashtable.)

Download the Project

Click here to download a sample project with this action.

The downloaded project has one more feature: it suppresses the normal output from PsLogList. Only our custom information is shown in the log.

Action output

Here's the log output from when the action is run normally:

Frequencies for different sources
Value Name
----- ----
29 Service Control Manager
3 Application Popup
2 W32Time
2 IPSec
2 EventLog
2 WinHttpAutoProxySvc
1 DCOM
1 AeLookupSvc
1 Tcpip6
1 Tcpip
1 redbook

Why this is Useful

OK, so this example isn't particularly relevant for automated builds. However, this technique (or one like it) can be used to parse information from any tool which is run by FinalBuilder.

Notes

Having a script event run every time data is logged decreases the performance of the action. For actions which log very large amounts of data, it's better to use Log To Variable and then process the output all-at-once in a separate action.

You'll note that the actual regular expression call used in the script event is different to the example expression showed at the beginning. We have to call the .NET RegularExpression class directly in order to use MultiLine mode. (If anyone from the PowerShell Team is reading this, please try and find a way to set the expression mode with simpler syntax!)

You can actually do everything shown in the example with JavaScript instead of PowerShell, using a Regexp object and an associative array. However, some steps (like automatically printing the results) are much more complex to do with JavaScript.

You could also get the same results from a PowerShell action by using get-wmi and the Win32_NTLogEvent class. That will be the subject of upcoming blog post Part Three: Custom actions.

FinalBuilder 6 : PowerShell (Part One, Execute Conditions)

Tue, 18 Mar 2008 05:00:00 GMT

Introduction

PowerShell support in FinalBuilder 5.5 was limited to the Execute PowerShell Action. For FinalBuilder 6, we've made PowerShell a "first class" scripting language, alongside JavaScript and VBScript.

This is the first in a series of blog posts which show the different ways PowerShell can integrate with FinalBuilder. Today's example is the Execute Condition.

Execute Conditions

Every action in FinalBuilder has a field called the "Execute Condition", on the Runtime property page.

This lets you place a single line of script which evaluates as a boolean condition. If the script evaluates "True", the action will execute. If the script evaluates "False", the action will be skipped.

PowerShell Execute Conditions

Due to it's terse but expressive syntax, PowerShell seems to lend itself to one-line expressions (a quick Google search will confirm this.) This can be great for execute conditions.

Examples

If you want an action to only run if Notepad is executing, you can use this one-line expression:

get-Process | where {$_.name -eq "NotePad"}

If you want an action to run only if a remote computer is online, you can use this expression:

gwmi Win32_PingStatus -Filter "Address='remotePC'" |where {$_.StatusCode -eq 0}

PowerShell treats any non-null value as equivalent to $True, so any result will be regarded as True, while no result will be regarded as False.

Caveats

I think one-liners are neat. It's probably because they remind me of growing up with my Apple //e and Nibble magazine's one-liner competition. However, like anything else, one liners can be abused. They can be the stuff of programming horror stories.

My suggestions for responsible Execute Condition use:

Put something in the action comment field if the Execute Condition isn't self-documenting.
Use a script event if the Execute Condition gets longer than the text field on the Runtime page.

Next - Part Two : Script Events

( Credits : thanks to beta tester Robert for the Notepad suggestion.)

Team Foundation Build and FinalBuilder 6 (a match made in heaven)

Fri, 14 Mar 2008 05:00:00 GMT

I just posted a new article on Integrating FinalBuilder with Microsoft Team Foundation Server. The article deals with the great new Team Build integration in FinalBuilder 6.

You can now do things with FinalBuilder 6 and Team Build which are impossible to achieve with any other tool combination, and you can do it all without editing any MSBuild files at all.

Need MbUnit test statistics in your Team Build Quality Report? Do it with FinalBuilder.

Need to deploy build results via FTP? Do it with FinalBuilder.

Need to build legacy Visual Studio 2003/Delphi/C++ Builder/VB 6 projects with Team Build, and see compiler metrics in the Team Build Report? Do it with FinalBuilder.

Need smart version information management (including auto-incrementing version numbers across projects) without having to use custom C# code? Do it with FinalBuilder.

Need to do perform any of the thousands of other built-in operations, with full graphical configuration and structured logging output? Do it with FinalBuilder.

If you're interested, check out the new article here.

I also wanted to plug a great (FREE) Screencast creator called Wink, by DebugMode Software. Paul put me onto this and I used it to create the Flash videos in the article. We also have a license to an expensive commercial product, but I don't think I'll ever want to use it again now that I've found Wink.

Variable Suggestion in FinalBuilder 6

Wed, 12 Mar 2008 05:00:00 GMT

Variables in FinalBuilder make your build process more maintainable, but working out which variables to use where can be difficult, especially when you are trying to retrofit them into an existing project. Variable Suggestion is a new feature in FinalBuilder 6 which aims to ease the use of Variables.

Variable Suggestion is a very simple feature. In any text field, press F12. FinalBuilder will scan the text in the field and determine if there are possible variable replacements that could be made. It does this recursively (not infinately though, we limited the depth to preserve reasonable performance), and will then present the list of possible variable replacement. The order that the suggestions are shown in is based on the total number of characters replaced/saved by using the variables. Not a very scientifc method, but in practice we found that in most cases the top few suggestions are the ones that make sense.

FinalBuilder 6 Tech Article - .NET custom action API

Tue, 04 Mar 2008 06:00:00 GMT

I just posted a new tech article about the FinalBuilder 6 .NET Custom Action API.

If you've ever done any custom action development with .NET, then I strongly suggest you check this out. It's a really nifty API and it makes designing FB 6 actions incredibly simple.

In addition, it is still possible to tweak the API slightly to add functionality before FB 6 goes final - so please let us know if there's anything that you'd like to see added.

"The Bus Factor", Software Development practices, and FinalBuilder

Wed, 27 Feb 2008 06:00:00 GMT

(This blog post is shamelessly ripped off from based on Roy Osherove's praise of FinalBuilder(*) during a session at TechEd Barcelona last year.)

"[The Bus Factor] means if the developer who wrote [the project] is hit by a bus, you're screwed."

- Scott Hanselman

It's common to talk about the Bus Factor of a software project or a piece of code. Specifically, the Bus Factor is the number of people on your team who need to be "hit by a bus" (or change jobs, or change projects, or move away, or retire, or get sat on by an elephant) before the project is in trouble. The hallmark of a bad Bus Factor is having specialised, hard to access, knowledge which is only understood by one or two people on your team.

FinalBuilder encourages a good Bus Factor for builds.

To help demonstrate this, here's the Nant build process for one of my favourite .NET Open Source tools, NUnit:

(Start scrolling now...)

(**)

The build process is 2,688 lines of XML, spread amongst 33 XML files. I combined them all into a PDF to create the images shown above. NUnit uses NAnt, but if you're using MSBuild then your build process will look very similar.

Comparatively speaking, this a simple build process. The entire NUnit codebase is only around 70 thousand lines of C# code. The build above doesn't do anything particularly complex. Imagine how much worse this gets if either the codebase, or the level of functionality, needs to grow.

Would you want to be a new developer in charge of working on that build process?

For comparison sake, I recreated most of the NUnit build functionality in FinalBuilder (this is based on a rolling demo that we used at TechEd Barcelona.)

The FinalBuilder project doesn't do absolutely everything that the NAnt script does, but it could be extended to fill in the gaps without changing the appearance drastically from what you see here. The FinalBuilder project also does do some things that the NAnt project does not do - namely version control integration and FTP deployment.

Ask yourself: Which type of build process would I like to see deployed in my organization?

Nitpicker's Corner

This isn't an entirely fair comparison, because lots of the details about how the FinalBuilder project works are hidden away under the GUI abstraction. That's my the point, though: In FinalBuilder the project details aren't all in your face, but they're easy to find and understand if the person who wrote the build process happens to get hit by a bus.

Footnotes:

(*) For the record, we didn't ask Roy to praise FinalBuilder, and we definitely didn't pay him to do so. He said it all off his own bat. I hope he doesn't mind me quoting him. (back)

(**) I don't mean to pick on NUnit here. Naturally, OSS development involves different factors which come into play when choosing tools. That said, we'd be happy to offer the NUnit project a free license (or two) of FinalBuilder for use with internal build and configuration management. (back)

Safely Using Relative Paths in Actions

Tue, 26 Feb 2008 06:00:00 GMT

Using relative paths in a project is a good idea - they make a project more maintainable, readable and portable.

However, lately I've seen quite a few sample FinalBuilder projects where people are using this kind of relative path in their actions:

MySolutionFile.sln

.\MyProject\Installer\Project.iss

..\..\MyOtherProject\MyProject.dproj

The idea is that if the file is located relative to the project file path, the relative path will resolve to the right directory.

Great idea, right? Unfortunately, no.

These relative paths rely on the current Windows working directory for the process. Unfortunately, FinalBuilder and Automise only have limited control over this property. Various API calls (made by actions, scripts or the IDE) might change this directory unexpectedly.

The safe way to use relative paths in a FinalBuilder or Automise project is to use the variable %FBPROJECTDIR% (called %PROJECTDIR% in Automise.) This variable evaluates to the directory which contains the current project file.

Unsafe	Safe
MySolution.sln	%FBPROJECTDIR%\MySolution.sln
.\MyProject\	%FBPROJECTDIR%\MyProject\Installer\Project.iss
..\..\MyOtherProject\MyProject.dproj	%FBPROJECTDIR%\..\..\MyOtherProject\MyProject.dproj

We recommend defining new project variables to prevent these paths from becoming too long and unwieldy, and to make your project easier to read.

For instance, you could define a project variable called InstallerPath and set it to %FBPROJECTDIR%\MyProject\Installer. Turn on the "Macro" option for the InstallerPath variable to make sure variable references are expanded each time the variable is read.

XML Actions and the "XPath returned no node" error.

Mon, 25 Feb 2008 06:00:00 GMT

(It's been a while since I blogged about anything, so I thought I'd write about this while my coffee kicks in on a Monday morning.)

An issue which comes up quite often is people seeing this error when they try to use XML actions in FinalBuilder or Automise:

XPath returned no node : /Project/Import

The reason is because of the way MSXML deals with document namespaces. If your XML file uses XML namespaces (and most do), then you need to tweak the action slightly.

I'm not going to go into XML Namespaces in detail. There are better places to learn about them. I'll just show you an example:

Example

Say you have a Visual Studio 2005 .csproj file (which is really just an XML file wearing a funny hat.) You want to iterate over all of the imported project names with an XML Node Iterator action. If you try to use the XPath /Project/Import, then you'll see the error I showed above.

Here's the first line of the .csproj file:

This means the document has a default XML Namespace, which is "http://schemas.microsoft.com/blahblahblah". This is why MSXML can't follow the XPath properly.

To fix this, open the XML action and navigate to the "MSXML Parser" page.

Turn on the "Automatically use namespace prefixes..." checkbox, and type a letter in the field for the default Namespace. I used "x" in the screenshot shown above.

Now change your XPath from /Project/Import to:

/x:Project/x:Import

It works! Namespace prefix "x" now refers to the default namespace in the document.

Pedantic Details

There is a way to specify the namespace URI as part of the XPath, without using this prefix feature, but the resulting XPaths are enormous and hard for humans to read.

If you have namespace prefixes defined as attributes in the document root node, ie s:xmlns="http://www.myfunkyurl.com/namespace", then turning on this option will let you use the prefixes in your XPath.

This is the best solution we've come up with so far. We're planning to revisit this in future and (hopefully) make it all automatic without any manual configuration or custom prefixes.

MSBuild Wish List vs FinalBuilder Feature Set

Fri, 07 Dec 2007 03:47:46 GMT

The MSBuild Team recently posted a "wish list" of potential new MSBuild features, and encouraged people to vote on which ones they would like to see in future versions. The results came out last week.

We have a lot of respect for MSBuild here at VSoft Technologies. We're committed to making our own MSBuild support top-notch so you can easily interoperate between FinalBuilder and MSBuild projects. However, I wouldn't recommend MSBuild for end-to-end build automation.

I couldn't help but compare the top ten most popular MSBuild feature requests with existing FinalBuilder features.

1) Debugger

FinalBuilder gives you a full graphical debugging environment - breakpoints, stepping, watches, pause and resume.

You also get a structured log which quickly allows you to move between your project's structure and it's output. No need to scan text log files for line numbers and target names.

2) and 3) These both relate to converting existing non-MSBuild-friendly formats to MSBuild. This problem is more or less bypassed if you use FinalBuilder, because the built-in action types give you "first class" access to building these project types.

4) Visualization

This is another feature that FinalBuilder gives you "out of the box" - FinalBuilder projects are represented as structured trees, and refactoring is often as simple as drag-and-drop.

5) Native Code / VC Support

FinalBuilder has built-in support for Visual C++, at the same level of integration as other tools.

6) Distributed Builds

FinalBuilder doesn't do this either. Yet.

7) Extensible reuseable inline tasks

Every single action in FinalBuilder has extensibility built in via VBScript, JavaScript, and soon PowerShell. (Ssh! Don't tell anyone I told you!) If that's not enough, with ActionStudio you can whip up a custom action type in minutes, using one of these scripting languages or .NET.

For further extensibility, resuseable action lists can be easily created and called from different parts of your project.

8) Multiprocessor Peformance

Async Action Groups let you automatically schedule parts of your build to run in parallel with others, allowing you to take advantage of multiprocessor architectures.

9) Extensible Functions

See No. 7. The inclusion of scripting throughout a FinalBuilder project makes it easy to extend specific fields.

10) (Editing UI)

This is FinalBuilder's core feature. The FinalBuilder IDE gives you a clear graphical layout of your build process, and combined with debugging and structured logging you have a quick and easy way to move between project structure and project output.

"I have Microsoft Team System, why do I need FinalBuilder?"

Wed, 07 Nov 2007 14:19:44 GMT

I'm writing this entry from a delegate work area at TechEd Barcelona. We've been talking to a lot of people over the past two days about FinalBuilder.

Many people have said "Oh, we have Team System. We already have automated builds." The surprising thing is how many people don't realise what they're missing out on, or that FinalBuilder can integrate directly with Team System.

With Team System you can do this in your build:

Get a fresh copy of your project's source
Build one or more Visual Studio 2005 solutions
Run Visual Studio tests & Visual Studio code coverage analysis
Deploy built applications to a network share

... that's about it.

Not that this is a bad thing - sometimes all you need to do is to build a solution, and you're done. It's still an automated build, and it's a world better than F5 as a build process.

However, with FinalBuilder you can easily extend Team Build to:

Change the build process without editing XML
Automatically update and increment version information
Build solutions with any version of Visual Studio or MSBuild
Create, edit or remove Work Items based on build outcomes
Deploy to multiple locations, or via FTP
Build third party projects
Build installers
Run tests using different test frameworks
Build multiple versions or editions of the same product
Build legacy code (possibly using different tools)
Retrieve source code from legacy source repositories
Generate structured build logs, with the ability to instantly jump to any points of failure.

FinalBuilder slots directly into Team Build as a build engine, in place of (or beside) MSBuild.

At TechEd, many people have recognised that they face one or more of these scenarios. A few have no other build requirements, but a lot of people have said "Oh, we've been doing that manually" or "Yes, we've been doing this with MSBuild but it's hard and it keeps breaking."

These are the cases where FinalBuilder can help create a true end-to-end build and release system, one which saves time and money and helps safeguard build quality and avoid last-minute surprises.

... and no more XML files!

Window resizing issues on 64 bit Windows

Wed, 17 Oct 2007 04:20:17 GMT

I just spent the better part of 3 days trying to find out why the FinalBuilder IDE was not resizing properly on my machine. I have Windows Vista Business X64 on my machine, and found that code that worked perfectly on XP was not working on Vista. After many hours of debugging our source and the source to some third party components, I got nowhere. I realised that I hadn't tested this on another Vista X64 machine, and sure enough... it worked fine on another machine.

My first thought was to update my video drivers, and after rebooting and logging in to the machine, it seems the problem was resolved. However, as I was sitting there, resizing the window of my test application, the problem suddenly re-appeared! Since there were other applications still starting up at the time, it became a process of elimination.

The culprit is Logitech SetPoint, which came with my Wireless keyboard & mouse (which I no longer use as they died when the office was flooded). Close SetPoint, and my test app (and FinalBuilder and Automise) resize properly. Start it up again and the problem is back.

Since find the cause, we have tested on Vista 64 bit, Vista 32bit, XP 64 bit and XP 32bit. The problem only shows on 64 bit versions of windows. I suspect this issue is one that Jordan Russell talks about here :

http://news.jrsoftware.org/news/toolbar2000/msg07779.html

So to sum up, if you see applications not resizing or not painting properly when resizing on 64 bit windows, see whether you have Logitech SetPoint running or not.

Automise, FinalBuilder and XML Formatted Data

Thu, 05 Jul 2007 22:36:17 GMT

Now and again people comment that they think FinalBuilder or Automise uses proprietary binary formats. I sympathise entirely. Binary formats are a pain to work with in version control, and a format like XML can be great when you need to make a sweeping change or tweak something. (If the people who make our help authoring tool are reading this post, please take note!)

The good news is that all of FinalBuilder and Automise's data is available via XML or raw text, you just need to know how to look for it!

The project files are XML

Both Automise and FinalBuilder save their project files as XML. If you save in the .FBP5 / .ATP2 "uncompressed" project format, then the project file is actually just an XML document. The XML isn't exquisitely formatted for human eyes, but a machine will be able to read it just fine..

If you save in the .FBZ5 / .ATZ2 "compressed" project format, the project file is compressed using industry-standard zip compression. If you rename the file to .ZIP, and open it in a zip program (like 7zip), then you can view or extract the uncompressed project file inside.

To choose whether to save "compressed" or "uncompressed" by default, go to Tools -> Options -> General IDE Options -> Design Time Options:

Project logs can be exported as XML

OK, you've got me. Automise and FinalBuilder project log files (.fbl5 and .log2) are a proprietary database format. In the old days, FinalBuilder 1 & 2 used a text formatted log file (or so I'm told.) This led to performance problems with large log files and long running projects. Hence the move to an embedded database engine.

However, you can still export any project log as XML. To export a single log, go to the History tab, select a log, and click "Export Log to XML" (or HTML, or plain text.) To export the current log automatically as part of a running project, use the Export Log action:

Logs can be exported as text, HTML, or XML. XML formatted logs can be further tweaked via XSLT. It is possible to pass data from FB/AT to the XSL stylesheet, via the use of extra XSLT parameters. If you're interested in writing an XSL transform for the Export Log action, take a look at the "Stylesheets" directory in the FinalBuilder or Automise program directory. It contains the XSL files which are used to do the exports for text, xml and html.

The Other Project Files are INI Files

Any extra project files (like the FBD data file, or the FBV persistent variables file) are actually INI files which can be viewed in any text editor. Go ahead and try it!

... armed with this knowledge, you should be diffing, merging, checking in, parsing, cutting, pasting and transforming in no time!

Windows Vista compatibility

Wed, 23 May 2007 05:00:00 GMT

Now that FinalBuilder 5.5 is out, I've posted a short article detailing some of the things to keep in mind when using FB with Windows Vista and User Account Control (UAC.) The article can be found here.

On a more techy subject, most developers are probably already well and truly up to speed with Vista integration by now, but here are a few resources that I found invaluable while getting a grip on the concepts of UAC, manifests, elevation, virtualization, and the elevation prompt.

User Account Control Overview at Microsoft TechNet. A good semi-technical (code-free) overview of UAC.
Evolving the Software Organism: Default Namespaces and UAC Manifests in Windows Vista. Covers some gotchas when embedding a UAC manifest.
Kenny Kerr's Windows Vista for Developers (Part 4). Great code summary of the two ways to request UAC elevation in Vista. Creating a process with an elevated token, or creating an elevated out-of-process COM object.
Windows Vista Application Development Requirements for User Account Control Compatibility. 500-pound-gorilla Word document, covers everything you ever wanted to know (and then some.)

Happy Vista-ing!

What's new in FinalBuilder 5 - FinalBuilder VariableSense™

Wed, 27 Sep 2006 05:00:00 GMT

As software developers, we've all be spoiled by modern development IDE's like Microsoft Visual Studio, Borland Delphi, JBuilder etc. We've become so accustomed to the Code Completion or Intellisense features that we find it hard to write code in notepad these days! Every day, we deal with class libraries with hundreds or even thousands of classes, methods, variables etc and we couldn't possibly remember the names of every identifier. How many times a day do you find yourself typing a class or type name in the code editor, then typing a dot and waiting for the Intellisense drop down list to appear, and then spend a few minutes exploring what's on offer. Well, why should it be any different when working in text fields in FinalBuilder (the script editor already has a code completion feature)? Enter FinalBuilder VariableSense™.

Simply Type the Variable delimeter character ( % ) and down pops a list of variables available. As you type the list is filtered. You can use the up/down arrow keys and page up/down keys to scroll the list, hit enter to insert the currently selected entry.

VariableSense™ works in all Edit Boxes and Combo Boxes that allow typing. In the future we'll be extending this to other control types such as grids etc.

Mixing up FinalBuilder with Team System (no more XML files!)

Thu, 17 Aug 2006 14:00:00 GMT

One of the comments that we frequently hear from users is "I couldn't do xyz with MSBuild, but I can now with FinalBuilder."

This is great, but hardly surprising. FinalBuilder includes out-of-the-box support for many more tools and processes than MSBuild. Not to mention that it has a GUI to set up your build process - no more editing XML files!

Lately, though, an increasing number of our users are moving to Microsoft Team System. One of the cornerstones of the Team System process is the Team Foundation Build engine, which is built on top of MSBuild.

Now, the Team Foundation Build wizard is fine if you only need to create simple build processes. Get some files, build some solutions, deploy some binaries to a file share. If you need to do anything more, though (and who doesn't?), then you're stuck back in XML land... The same applies if you want to edit your build processes after you've created them.

Plain XML editing, with no built-in support for third-party tools, no support for data processing, no support for parallelisation, FTP transfers, Active Scripting, structured exceptions, recursion or Windows system functionality...

FinalBuilder to the rescue!

The Team Foundation Build engine allows you to add custom MSBuild tasks at any stage of your build process. This means that, with just a couple of lines of XML, you can move your entire Team Build process to FinalBuilder! FinalBuilder can be used in place of MSBuild to provide functionality at every stage of the Team Foundation build process (fetch, compile, test & deploy.) What's more, it all fits perfectly within the Team System framework!

To see how, take a look at the walkthrough I just wrote: Integrating FinalBuilder with Microsoft Team Foundation Build.

... Happy building!

File Dependencies

Thu, 17 Nov 2005 01:18:00 GMT

Have you ever wished you can have your build check whether or not files have changed, so you know whether or not to rebuild?

With FinalBuilder 4, you now can! Check out the new File Dependency action (you will need the latest public beta.)

This is a skeleton action list that does two things:

It synchronizes a local copy of the source files (via SurroundSCM Get.)
It checks the file dependencies to see if anything has changed. Lets zoom in on the File Dependency action:

In Files and Folders to check, I'm telling FinalBuilder to look at the modification dates of all the main FinalBuilder source and resource files. Because I've chosen Recurse into subdirectories, FinalBuilder will scan the subdirectories of each for all files of those types.

So, how do we know if the files have changed?

As you can see, I've told FinalBuilder to check for any files which have changed since the last time the action was run. In the Options section, I've elected to have FinalBuilder ignore any files created within two minutes of the last run, to compensate for jitter in the modification dates.

You can see in the greyed-out “Use date from file“ section that I could have elected to compare the modification dates of the compiled libraries, in order to be really sure whether or not to rebuild.

In fact, you can build a simple continous integration tool with just one more action:

Example1 re-schedules itself (using the Schedule Add action and the Windows Scheduler) to run 10 minutes after it finishes, but only starts a build if there are files that have changed.

Example 2 is even simpler - it loops continously checking for changed files (with a short delay in between each loop.) I also put in a separate check so the help file is only rebuilt if it has changed.

FinalBuilder 4 - more on Async Action Groups

Wed, 19 Oct 2005 01:04:00 GMT

Tate blogged about Async Action Groups a few weeks ago, however there is a lot of confusion about how they work amongst the beta testers(something we need to address in the documentation!). I'm going to explain here exactly how they work and discuss some of the limitations inherent in threaded builds.

Lets take a look at an Action List with an async group :

In the above example, Action 1, Action 2 and Action 3 will be started simultaneously. Each immediate child action of the Async Group is treated like an action inside their own action lists, and this is in fact how it is implemented. The actions are mapped onto a pseudo action list object and then the pseudo action list object is executed in it's own thread with it's own execution engine.

If we look at the above list, the general execution order will be something like :

(in thread 1) Action 1, Action 1.1, Action 1.2, Action 1.2.1
(in thread 2) Action 2, Action 2.1, Action 2.2, Action 2.2.1
(in thread 3) Action 3, Action 3.1, Action 3.2, Action 3.2.1

The actual execution order (ie the real time execution order) would probably be completely different depending on which actions are used and how long they take to execute, however Action 1,2 & 3 will always start at pretty much (give or take a few milliseconds) the same time.

So now we know how Async Groups are supposed to work, lets mull over some of the implications of using Async Groups and look at some of the limitations. Just like threading in your application code, Async Groups are no silver bullet. Having two or more actions running in parallel will not necessarily translate into reduced build times. Your milage will vary, depending on whether your actions are I/O bound, or CPU bound. Running two cpu bound actions in parallel will probably increase the time they take compared to running them in serial. The same applies to i/o bound actions. So the smart thing to do is run a cpu bound action in parallel with an i/o bound action. Of course, if you are running your builds on multi-cpu machines with very fast hard disks and gigabit Ethernet then these rules go out the window.. and trial and error will prevail.

So what limitations are there with Async? Well, some actions need exclusive access to a resource, for example the Visual Source Safe actions change settings in the ss.ini file before running the source safe command line tool. These settings need to be changed for the command line tool to give us the behavior we require. So what happens if we execute two source safe actions together? The results are unreliable at best. In the current beta (build 31), we don't have anything to prevent this from happening. In the next build we upload, we have implemented a generic resource locking scheme in the execution engine, so that when an action is executed, it can indicate whether it needs a resource lock or not. The source safe actions will now provide this indication, and the net effect is that the source safe actions will be serialized, even if they are running in an async group. This applies only to source safe actions using the same srcsafe.ini file (ie vss database). If another source safe action is using a different database then that action would not require serialization. The same applies to the CD Burner and Create ISO actions. In our tests, we found that the cdburner library we use is not thread safe and so requires locking. In the next few weeks we'll be testing all the actions in Finalbuilder for thread safety and implementing resource locking as required.

Another limitation is that you cannot use the “Run Actionlist“ and “Include FinalBuilder Project“ actions under an Async group. The reasons for this are complicated. If the same actionlist was executed multiple times, it would require multiple instances of the action list to avoid re-entrance issues, and that brings with it a whole host of other related gotchas. While I do plan to spend some more time investigating enabling these actions under Async Groups, I'm not expecting that this will happen before 4.0 is released.

When we looked at adding the Async Group action during our planning for FinalBuilder 4, we figured people might potentially achieve 10-15% faster builds. So far, the feedback from beta testers has proven that to be the case. In our own builds, we achieved around a 5% boost, on a single cpu VMWare virtual machine. We did try the virtual smp support in VMWare 5.5 beta, however it actually resulted in slower builds. We'll try again when VMWare 5.5 is released.

CruiseControl.NET

Wed, 05 Oct 2005 02:46:00 GMT

I've also been working on a FinalBuilder plugin for the open source continuous integration tool, CruiseControl.NET.

We're still testing the plugin right now, but it will be released in time for FinalBuilder 4. You can add a FinalBuilder project to CruiseControl.NET with just two XML tags!

If you would like to beta test, please let us know.

New XML Actions

Wed, 05 Oct 2005 02:32:00 GMT

I'm now into my fourth month here at VSoft, so it must be about time for a first blog post!

I've been working on all kinds of new actions for FinalBuilder 4. I think lots of you who requested features will be very happy with the upcoming release (and everyone else should find something useful, too.)

Today I just wanted to demonstrate two new XML actions : the XML Iterator and the XML Read from Variable Action. Combined with the already strong XML support in FinalBuilder, you can work with data from almost any XML file. Allow me to demonstrate:

Here's the project:

The XML file I'm iterating is a 3Mb chunk of the Javanese edition of the Wikipedia, exported as XML. I'm going to catalogue all the users who made edits, and record their usernames as well as any comments they recorded. I don't want to record revisions by the automatic MediaWiki bots.

So, I iterate through the XPath /mediawiki/page/revision, saving the absolute XPath in to each revision in the 'Page' FinalBuilder variable:

Once I have the absolute XPath to each node, I can read the 'Comment' and 'Contributor' tags into FinalBuilder variables. Here's the action which reads 'Comment':

The 'Comment' tag is optional, so I use a Try... Catch block to blank out the comment if there isn't one.

Together with a 'Write Text File', these actions are all you need to create a list of contributors and their comments.

This sort of technique can be used to parse any kind of XML file as part of your build process. If you need to, you can even create an XML file which gives instructions to your build process. But who'd want to do that?