Random Musings of Jeremy Jameson : My System

Building SharePoint WSPs with Team Foundation Build

Jeremy Jameson — Wed, 18 Nov 2009 13:45:00 GMT

As I noted in my previous post, I recently discovered that my approach for building Web Solution Packages (WSPs) in Microsoft Office SharePoint Server (MOSS) 2007 isn't compatible with Team Foundation Build.

I'm actually a little embarrassed to say this, but when I created the original "DR.DADA" approach for MOSS 2007 development back on the Agilent Technologies project, we were using Visual SourceSafe -- not Team Foundation Server (TFS) -- and a "manual" build process.

I'd used VSS and automated builds on other projects before (using NAnt), but never got around to automating our MOSS 2007 builds on the Agilent project because, honestly, there were just too many other higher priority items. Besides, each build only required a couple of minutes of actual human effort because most of the build was scripted.

Still, an automated daily build (and deployment to DEV) is a really, really good thing to have.

I've been fortunate to be on a few projects since then that have leveraged TFS.

However, up until about a month ago, I hadn't used Team Foundation Build (outside of the Jameson Datacenter, of course) due to the fact that we are leveraging the extranet TFS instance hosted by Microsoft.

Note that Microsoft IT makes it very easy for us to provision new TFS projects on either the extranet or one of several internal TFS instances. Configuring builds using Team Foundation Build on one of the intranet TFS instances is very easy (from what I hear), but I strongly prefer working off the extranet TFS instance because then I don't have to VPN into CorpNet in order to have access to source control.

However, choosing the extranet TFS instance also means we can't configure builds using the out-of-the-box functionality in Team Foundation Server (at least not without setting up a build server on the extranet). Fortunately, I've found a way to schedule "manual" builds that look a lot like automated builds performed using Team Foundation Build.

So, if you are building SharePoint WSPs -- regardless of whether you use the real Team Foundation Build or my "imitation Team Foundation Build" -- you need a way to build the WSPs without referring to referenced assemblies using relative paths.

As I first mentioned in my previous post, relative paths work just fine when compiling from within Visual Studio or using MSBuild from the command line. However, they don't work at all when queuing the builds through Team Foundation Build.

The problem with relative paths is that Team Foundation Build uses a different folder structure when compiling your projects. Specifically, it changes the output folder for all compiled items to be under a new Binaries folder -- not the location specified in the project settings within Visual Studio.

In other words, if you refer to a referenced assembly using something like:

..\..\..\CoreServices\bin\%BUILD_CONFIGURATION%\Fabrikam.Demo.CoreServices.dll

then you will find that this works just fine when building through Visual Studio -- or even when compiling using TFSBuild.proj from the command line (a.k.a. a "Desktop Build"). However, if you then queue the build through Team Foundation Server, you'll find your build fails because the referenced assembly was actually output to a different folder.

If you dive into the log file for the build, you will find that Team Foundation Build modifies the OutDir variable and sets it to something like:

C:\Users\svc-build\AppData\Local\Temp\Demo\Daily Build - Main\Binaries\Debug\

So the trick to building WSPs with Team Foundation Build is to leverage the OutDir variable instead of relying on relative paths to referenced assemblies.

Here is the updated DDF file based on my earlier sample:

;
; This ddf specifies the structure of the .wsp solution cab file.
;
; HACK: OPTION EXPLICIT cannot be used when specifying a variable with the /D option,
; otherwise MakeCAB aborts with an error similar to the following:
;
;        ERROR: Option Explicit and variable not defined: OUT_DIR
;
;.OPTION EXPLICIT    ; Generate errors for undefined variables

.Set CabinetNameTemplate=Fabrikam.Demo.Publishing.wsp

; The following variable must be set when calling MakeCAB (using the /D option)
;.Define OUT_DIR=

.Set DiskDirectoryTemplate=CDROM    ; All cabinets go in a single directory
.Set CompressionType=MSZIP            ; All files are compressed in cabinet files
.Set UniqueFiles=ON
.Set Cabinet=ON
.Set DiskDirectory1=%OUT_DIR%\Package

DeploymentFiles\PackageFiles\manifest.xml

.Set SourceDir=%OUT_DIR%            ; Copy assemblies from %OUT_DIR% folder

Fabrikam.Demo.Publishing.dll
Fabrikam.Demo.CoreServices.dll

.Set SourceDir=                    ; Copy files relative to project folder

.Set DestinationDir=Fabrikam.Demo.Publishing.DefaultSiteConfiguration
DefaultSiteConfiguration\FeatureFiles\Feature.xml

.Set DestinationDir=Fabrikam.Demo.Publishing.Layouts
Layouts\FeatureFiles\Feature.xml
Layouts\FeatureFiles\ProvisionedFiles.xml

.Set DestinationDir=Fabrikam.Demo.Publishing.Layouts\MasterPages
Layouts\MasterPages\FabrikamMinimal.master

;.Set DestinationDir=Fabrikam.Demo.Publishing.Layouts\PageLayouts
;Layouts\PageLayouts\MinimalPage.aspx

.Set DestinationDir=Fabrikam.Demo.Publishing.Layouts\Images
Layouts\Images\FabrikamLogo_32x32.png

.Set DestinationDir=Fabrikam.Demo.Publishing.Layouts\Themes\Theme1
Layouts\Themes\Theme1\BreadcrumbBullet.gif
Layouts\Themes\Theme1\FauxColumn-Fixed-2Col.png
Layouts\Themes\Theme1\FauxColumn-Fixed-3Col.png
Layouts\Themes\Theme1\Fabrikam-Basic.css
Layouts\Themes\Theme1\Fabrikam-Core.css
Layouts\Themes\Theme1\Fabrikam-FixedLayout.css
Layouts\Themes\Theme1\Fabrikam-IE.css
Layouts\Themes\Theme1\Fabrikam-IE6.css
Layouts\Themes\Theme1\Fabrikam-QuirksMode.css
Layouts\Themes\Theme1\Tab-LeftSide.jpg
Layouts\Themes\Theme1\Tab-RightSide.jpg

.Set DestinationDir=ControlTemplates\Fabrikam\Demo\Publishing\Layouts
Layouts\Web\UI\WebControls\GlobalNavigation.ascx
Layouts\Web\UI\WebControls\StyleDeclarations.ascx

.Set DestinationDir=Layouts\Fabrikam
Layouts\MasterPages\FabrikamMinimal.master

Note how I've replaced the BUILD_CONFIGURATION variable with the OUT_DIR variable. Not surprisingly, the OUT_DIR variable in the DDF is specified similar to how BUILD_CONFIGURATION was previously specified when calling makecab.exe. However, unlike the build configuration the OutDir variable will likely contain spaces as well as a trailing slash (which makecab.exe apparently doesn't like). Therefore we must quote the OutDir variable and append with "." if a trailing slash is found.

Here is the corresponding update to the project file:

  <PropertyGroup>
    <BuildDependsOn>
      $(BuildDependsOn);
      CreateSharePointSolutionPackage
    </BuildDependsOn>
    <QuotedOutDir>"$(OutDir)"</QuotedOutDir>
    <QuotedOutDir Condition="HasTrailingSlash($(OutDir))">"$(OutDir)."</QuotedOutDir>
  </PropertyGroup>
  <Target Name="CreateSharePointSolutionPackage" Inputs="@(None);@(Content);$(OutDir)$(TargetFileName);" Outputs="$(ProjectDir)$(OutDir)Package\Fabrikam.Demo.Publishing.wsp">
    <Message Text="Creating SharePoint solution package..." />
    <Exec Command="makecab /D OUT_DIR=$(QuotedOutDir) /F &quot;$(ProjectDir)DeploymentFiles\PackageFiles\wsp_structure.ddf&quot;" />
  </Target>

With these changes, the SharePoint WSP is successfully built regardless of whether it is compiled through Visual Studio, from the command line using MSBuild and the TFSBuild.proj file, or as an automated build using a Team Foundation Build server.

A Simple Backup Solution

Jeremy Jameson — Mon, 09 Nov 2009 13:44:00 GMT

As I've mentioned before, I don't spend much money or time maintaining the "Jameson Datacenter" (a.k.a. my home lab). However, that doesn't mean that I treat my infrastructure lightly.

In previous posts, I've covered many of the Group Policy objects that I use to minimize the maintenance effort associated with running more than a dozen servers (mostly virtual). In this post, I'll provide the details on how I backup these servers.

I should preface this by saying this is not meant to be an "enterprise-level" backup solution. Rather it is simply meant to provide a cheap (actually free) and easy solution to the problem of ensuring you can recover from data loss. Note that data loss rarely occurs through some sort of hardware failure or Act of God (as the insurance folks like to put it). Rather the majority of the time someone accidentally overwrites or deletes a file -- or, gasp, a complete folder hierarchy -- and you subsequently need to restore the data from a backup.

For as long as I can remember, Windows Server has included the NTBackup utility. I'm guessing from the name that this has been around since the days of Windows NT 3.1, but honestly I don't believe I even started running Windows NT until version 3.5. Or was it 3.51? I can't remember. Anyway, I certainly haven't been running NTBackup since then.

Here is the simple batch file that I use to perform scheduled backups:

@echo off

setlocal

set BACKUP_TYPE=normal

if ("%1") NEQ ("") set BACKUP_TYPE=%1

for /f "tokens=2-4 delims=/ " %%i in ('date /t') do set currentDate=%%k-%%i-%%j
for /f "tokens=1-2" %%i in ('time /t') do set currentTime=%%i %%j
set BACKUP_TIMESTAMP=%currentDate%-%currentTime:~0,2%-%currentTime:~3,2%-%currentTime:~6,2%

set BACKUP_FILE=D:\NotBackedUp\Backups\Backup-%BACKUP_TYPE%-%BACKUP_TIMESTAMP%.bkf

:: ----------------------------------------------------------------------------
call :LogMessage "Starting backup..."
call :LogMessage "BACKUP_TYPE: %BACKUP_TYPE%"
call :LogMessage "BACKUP_FILE: %BACKUP_FILE%"

C:\WINDOWS\system32\ntbackup.exe backup C:\BackedUp /n "Backup created %BACKUP_TIMESTAMP%" /m %BACKUP_TYPE% /j "Backup (%BACKUP_TYPE%)" /f "%BACKUP_FILE%"
if %ERRORLEVEL% neq 0 goto Errors

call :LogMessage "Successfully completed backup."

goto :eof

:: ----------------------------------------------------------------------------
::
:LogMessage

REM Strip leading and trailing quotes and then display message with timestamp
set MESSAGE=%1
set MESSAGE=%MESSAGE:~1,-1%

for /f "tokens=2-4 delims=/ " %%i in ('date /t') do set currentDate=%%k-%%i-%%j
for /f "tokens=1-2" %%i in ('time /t') do set currentTime=%%i %%j
echo %currentDate% %currentTime% - %MESSAGE%

goto :eof

:: ----------------------------------------------------------------------------
::
:Errors

echo Warning! One or more errors detected.

If you've seen any of my scripts before, then you'll quickly notice the typical LogMessage "function" that I use to write messages prefixed with a timestamp. For example here's the output from the log for this morning's backup:

2009-11-09 12:30 AM - Starting backup...
2009-11-09 12:30 AM - BACKUP_TYPE: differential
2009-11-09 12:30 AM - BACKUP_FILE: D:\NotBackedUp\Backups\Backup-differential-2009-11-09-12-30-AM.bkf
2009-11-09 12:31 AM - Successfully completed backup.

I use similar token parsing of the output from the date and time system commands to generate the name of the backup file (e.g. Backup-differential-2009-11-09-12-30-AM.bkf).

Also note that the type of backup (e.g. normal or differential) can be specified as a parameter when running the batch file. This is really powerful for scheduling different types of backups on various schedules.

Here are the scheduled backups on one of my servers (BEAST):

Scheduled Backups on BEAST
Name	Schedule
Daily Backup	At 12:00 PM every day
Differential Backup	At 12:30 AM every day
Full Backup	At 1:00 AM every Sun of every week

The Daily Backup task is configured as follows:

Run: C:\BackedUp\Backup.cmd daily >> Backup.log
Start in: C:\BackedUp
Run as: TECHTOOLBOX\svc-backup

Note that I specifically chose the middle of the day to perform daily backups so that I could potentially recover a file that was created in the morning but mistakenly deleted in the afternoon. I suppose I could schedule incremental backups throughout the day, but honestly, I haven't seen the need given my situation.

Also note that the service account that I use for backups (TECHTOOLBOX\svc-backup) is only a member of the Backup Operators group. It is not a member of the Administrators group.

Consequently there's a known issue with running batch files using scheduled tasks due to out-of-the-box security restrictions on cmd.exe:

"Access is denied" error message when you run a batch job on a Windows Server 2003-based computer

http://support.microsoft.com/kb/867466

Lastly, note that I am doing a simple disk-to-disk backup on my servers, so if there's a fire in the Jameson Datacenter (i.e. my basement) and I lose these servers completely then I'm going to be "hurtin' for certain." However should there ever be a fire in my basement (Heaven forbid), I'm going to be worried about a lot more than just restoring my data from backup. Note that I keep copies of the really important stuff (e.g. digital photos and home videos of my family) on DVDs at my parents' house.

I've read that there's a new backup tool in Windows Server 2008, so I suppose one of these days I'll need to get around to upgrading my backup solution ;-)

Using Password Minder to Manage Your Passwords

Jeremy Jameson — Sat, 07 Nov 2009 14:18:00 GMT

I started using Password Minder almost immediately after reading about it in the July 2004 edition of MSDN Magazine. I don't know about you, but trying to remember all of my various passwords for dozens of Web sites, numerous network accounts, VMs, etc. is really quite a nightmare. [I'm actually a little embarrassed to say that on more than one occasion I've had to hack one of my VMs in order to reset the password for a domain admin. This process definitely isn't for the faint of heart, but it was better than having to rebuild my FABRIKAM domain from scratch.]

Instead I tend to use no more than three or four passwords that I can remember (and change every couple of months) and a whole bunch of randomly generated passwords that I rely on Password Minder to store securely.

Note that all of the service accounts used in the "Jameson Datacenter" (a.k.a. my home lab) use random 20 character passwords.

Hence, why I added Password Minder to my Toolbox years ago. [Thanks to Keith Brown for sharing this wonderful utility, as well as take the time to write about the internals of how it works.]

However, there were a few problems I had with the original Password Minder.

First, it didn't like the fact that my Documents folder is redirected to a server. In other words, my encrypted password file is:

\\BEAST\Users$\jjameson\Documents\My Passwords.xml

Consequently, I encountered the following error when trying to save my password file:

Failed to save the password file. Here are the gory details:
GetVolumeInformation failed:
The filename, directory name, or volume label syntax is incorrect.

I discovered that I could avoid this error by clearing the Let Password Minder control the DACL checkbox in the Password Minder Options dialog window.

The next problem that I encountered was Password Minder throwing up on me (in other words, generating an unhandled IndexOutOfRangeException) when one of my passwords somehow ended up being an empty string (to this day I'm still not sure how that empty password managed to get saved to the file).

Thus I made a small change to line 381 of CryptMaster.cs. The original code was:

            if (null == record.EncryptedUserId) {

I changed this to:

            if (string.IsNullOrEmpty(record.EncryptedUserId) == true) {

The third problem (which I didn't encounter until a few years later) was that Password Minder wouldn't run on my Windows Vista x64 desktop.

Note that the original project settings specified Platform target: Any CPU and thus pwm.exe would generate a BadImageFormatException when trying to load the 32-bit NativeHelpers.dll.

Could not load file or assembly 'NativeHelpers, Version=1.5.0.4, Culture=neutral, PublicKeyToken=null' or one of its dependencies. An attempt was made to load a program with an incorrect format.

This was easy enough to fix simply by setting Platform target to x86 and then recompiling.

So, why do I blog about Password Minder after all this time? Well, just this week I finally got around to incorporating it into my "Toolbox" Visual Studio solution that is scheduled to build daily using Team Foundation Server, and I discovered that my Team Foundation Build server wasn't setup to build C++ projects, which is what I will blog about next.

Stay tuned...I need to eat some breakfast first ;-)

Using Robocopy to Move Files and Folders

Jeremy Jameson — Sat, 07 Nov 2009 13:46:00 GMT

I use Robocopy a lot, and it's been in my Toolbox for so long that I hardly remember using anything else. I was glad to see that it is now included out-of-the-box (starting with Vista), because I typically use it instead of Windows Explorer to move or copy files, since I prefer the way it reports the progress of the lengthy file operations.

Note that when you specify the "/S /MOV" or "/E /MOV" options (to recursively move files from one location to another), it may leave behind a bunch of empty folders depending on the contents of the source and what you specify to move.

Over a year ago I went through the rather painful effort of organizing my thousands of digital photos. During the process of moving thousands of files around to various folders, I ended up with lots of empty folders in my source folder structure.

As I discovered earlier this week, you can specify the /MOVE option (instead of /MOV) to move both the files and directories, and delete them from the source after they are copied.

Perhaps now my blog post from earlier this week about deleting empty folders makes a little more sense ;-)

Sometimes I'm amazed at what I learn while blogging. I had just been in such the habit of using the /MOV option that I never gave it any thought (that is, until this week).

Deleting Empty Folders

Jeremy Jameson — Tue, 03 Nov 2009 13:36:00 GMT

For the sake of this post, let's assume that you have a directory that contains some empty folders you want to get rid of. How the empty folders got there isn't important; all that matters is that you have some and you want to get rid of them.

A few years ago, I created the following script (starting from a sample I found in the Script Center on TechNet) to recursively enumerate a folder structure, identify any empty folders, and subsequently delete them.

Option Explicit

If (WScript.Arguments.Count <> 1) Then
    WScript.Echo("Usage: cscript DeleteEmptyFolders.vbs {path}")    
    WScript.Quit(1)
End If

Dim strPath
strPath = WScript.Arguments(0)

Dim fso
Set fso = CreateObject("Scripting.FileSystemObject")

Dim objFolder
Set objFolder = fso.GetFolder(strPath)

DeleteEmptyFolders objFolder

Sub DeleteEmptyFolders(folder)
    Dim subfolder
    For Each subfolder in folder.SubFolders
        DeleteEmptyFolders subfolder
    Next
    
    If folder.SubFolders.Count = 0 And folder.Files.Count = 0 Then
        WScript.Echo folder.Path & " is empty"
        fso.DeleteFolder folder.Path
    End If    
End Sub

As you can see, there's really nothing complex here. Nevertheless I still find it to be a very useful script from time to time, so I thought I should share it. I used it this morning and it occurred to me that I should throw it up on the blog.

Just be sure to run it with CScript -- and not the default WScript -- or you'll find the WScript.Echo messages rather frustrating.

Recommendations for Code Analysis

Jeremy Jameson — Sat, 31 Oct 2009 13:44:00 GMT

In my previous post, I briefly mentioned the Code Analysis feature of Visual Studio in the context of using check-in policies with Team Foundation Server (TFS). However, there's a lot more to talk about with regards to using Code Analysis.

If you are ever find yourself "starting from a clean slate" on a software development project, I hope you take advantage of the opportunity to not only enable Code Analysis, but also to treat all Code Analysis warnings as errors. That's right, go ahead and check all of those boxes (for both Debug and Release configurations, of course) so that whenever potential issues are reported by Code Analysis, it stops developers dead in their tracks and considers the build to be broken.

While you're at it, go ahead and select the All option in the Treat warnings as errors section on the Build tab (something I definitely recommend as a best practice). Again, be sure to do this for all build configurations.

Yes, this is going to be really painful for some developers.

For example, you can say goodbye to using the overload of string.Format() that doesn't specify a CultureInfo:

            string foo = "here";

            string logMessage = string.Format(
                "Imagine something interesting {0}.",
                foo);

Attempting this will now result in a broken build:

Error 2 CA1305 : Microsoft.Globalization : Because the behavior of 'string.Format(string, object)' could vary based on the current user's locale settings, replace this call in 'Program.Main(string[])' with a call to 'string.Format(IFormatProvider, string, params object[])'. If the result of 'string.Format(IFormatProvider, string, params object[])' will be displayed to the user, specify 'CultureInfo.CurrentCulture' as the 'IFormatProvider' parameter. Otherwise, if the result will be stored and accessed by software, such as when it is persisted to disk or to a database, specify 'CultureInfo.InvariantCulture'.

To avoid the CA1305 error, you will need to use something like this instead:

            string foo = "here";

            string logMessage = string.Format(
                CultureInfo.InvariantCulture,
                "Imagine something interesting {0}.",
                foo);

You will also need to enable signing of all assemblies with a strong name key, and also specify various assembly level attributes (e.g. [assembly: CLSCompliant(true)]). However, if you follow the steps I've provided in a previous post, this should only take you at most 1-2 minutes.

Like I said before, this will probably cause some heartburn in the beginning, but trust me, developers will quickly get used to it and the code they write will be much better as a result.

Now what about the other 99% of the time when you aren't starting from a clean slate, but instead are dealing with a substantial code base that causes the Code Analysis feature in Visual Studio to "light up like a Christmas tree" when you turn it on?

Well, as with all software bugs, it all comes down to triage. You obviously cannot simply halt all feature development in order to resolve code analysis issues. Instead, you should go for the "low hanging fruit" (meaning the issues that occur frequently but can be resolved with relatively little effort or risk of changing). You should also try to enable the Code Analysis rules that are most important, such as potential security issues.

The following post provides some great information about which Code Analysis warnings to focus your attention on first:

What rules do Microsoft have turned on internally? 2007-08-09.

http://blogs.msdn.com/fxcop/archive/2007/08/09/what-rules-do-microsoft-have-turned-on-internally.aspx

This article is obviously a little dated, but still very relevant over two years later.

Note that you will undoubtedly need to suppress some specific Code Analysis warnings from time to time, and therefore you'll have to choose how to suppress the warnings (whether inline within the source, or in a GlobalSuppressions.cs file). However, I hope you'll choose to fix the underlying issue that causes the Code Analysis warning (whenever practical) instead of simply suppressing a bunch of warnings.

So, in conclusion, think of the Code Analysis feature in Visual Studio as a way of choosing a more strict compiler. For example, back in the days when I used to program in C on Unix, the compiler wouldn't complain when I wrote something like this (even though this is obviously very wrong):

I was relieved when I switched to C++ and these kinds of bugs were a thing of the past. [Note that I never switch my coding style to use something like "1 == i" in order to avoid these errors.]

Fortunately, in C# you don't have a choice about whether or not this compiles (it doesn't).

I like to think of enabling all of the Code Analysis rules in a similar fashion. In other words, I want the compiler to tell me whenever I am doing something potentially wrong, because then I can spend just a little bit of time fixing my code to do it right. By forcing the Code Analysis warnings as errors, I don't have a choice -- meaning I have to fix them before check-in.

Recommended Check-In Policies for Team Foundation Server

Jeremy Jameson — Sat, 31 Oct 2009 12:14:00 GMT

I love using Team Foundation Server (TFS). There's just an amazing amount of "goodness" for software development that comes out-of-the-box; and there's even more available from Microsoft and other sources in the form of add-ons (many of which are free).

From a source control perspective, one of my favorite features is check-in policies. Anything that improves the quality of software development with minimal effort is really a "no-brainer" in my opinion.

The check-in policies that I prefer to have configured on all TFS projects are listed in the following table.

Recommended TFS Check-In Policies
Policy Type	Description
Builds	This policy requires that any code changes have been compiled and the last build was successful.
Work Items	This policy requires that one or more work items be associated with every check-in.
Changeset Comments Policy	Reminds users to add meaningful comments to their check-ins.
Code Analysis	This policy requires that Code Analysis is run with a defined set of rules before check-in.
Testing Policy	Ensures that tests from specific test lists are successfully executed before checking in.

The first two check-in policies are virtually painless and can be applied to any existing project at any time. These policies ship with Visual Studio Team System 2008, and assuming your developers have good software development discipline already, there's absolutely no reason not to enable these policies.

After all, why would any developer want to check-in code that hasn't been verified to at least compile? Similarly, why would a developer make a code change that isn't specifically related to a work item (even if that work item is simply something like "Refactor X" or "Code cleanup (M5)")?

However, the last three policies in the table above require a little more effort.

The Changeset Comments Policy is included in the Team Foundation Server Power Tools, which means that every member of the Development team will need to download and install this in order to use it. (Note that if you don't have the Power Tools installed, you can still override the check-in policy in order to avoid being blocked.)

The Code Analysis policy can definitely cause a little heartburn for your Development team, depending on how many code analysis rules you enable and whether or not you treat these warnings as errors. I'll talk more about Code Analysis in a separate post.

The Testing Policy is not one that I consider essential for all projects. For projects in which you have a good set of Build Verification Tests (BVTs) that give you a signficant amount of code coverage and don't take very long to execute, then enabling this policy just makes sense. However, keep in mind that you should definitely be running BVTs as part of your automated build, so if these tests require a substantial amount of time to execute (for example, they require signficant setup or teardown), then forcing developers to run these tests before every check-in could definitely impede their productivity.

Of course, you can always separate your tests into "quick tests" and "long running tests" like I've mentioned in a previous post, and consequently only require the "quick tests" to be executed before check-in.

If you are fortunate enough to be using TFS on your project, I hope you are reaping the benefits of check-in policies.

The Original "Jameson Datacenter"

Jeremy Jameson — Sat, 24 Oct 2009 13:18:00 GMT

This morning I was doing some cleanup of my documents folder and I stumbled across a rather old Visio document that showed the beginnings of what I now refer to as the "Jameson Datacenter" (a.k.a. my home lab). For some geeky reason, seeing this again brought a smile to my face and a sense of nostalgia. It also caused me to recall two things:

That old Greatful Dead song "Truckin'" -- specifically the line

Lately it occurs to me: What a long, strange trip it's been.

Update

Doh! You would think a guy with a Master of Science degree in Mechanical Engineering could spell "Grateful Dead" correctly! I suppose that I really should do more proofreading before clicking that Publish button ;-)
An article I read about a year ago describing the origin of Google that also included some photos of the original Google infrastructure in the Stanford University computer lab.

Now, please don't misunderstand -- I most certainly am not claiming that the Jameson Datacenter will ever amount to even the most miniscule fraction of what Google grew into in less than a decade. All I'm saying is that in the incredible way the neurons are wired together in the human brain, things that we see very often trigger distant memories with amazing clarity.

For those of you that may not have seen the original Google server farm, I did a quick search this morning and managed to find the following:

Google Stanford Hardware

http://geektechnique.org/media/google/googlehardware.html

If you haven't seen this, take a quick peek. It will surely bring a smile -- if not a burst of laughter.

After enjoying the nostalgia for a moment, I almost deleted the Visio diagram and continued my cleanup effort. However, then I decided that I might as well "archive" this on my blog. It definitely won't help your efforts of deploying Microsoft technology, but I think it's okay for a blog to wander a little every now and then -- perhaps for no other reason than to keep you guessing as to what may come next on the Random Musings of Jeremy Jameson.

Here's the physical architecture of what I now refer to as the "Old Jameson Datacenter":

Figure 1: Old Jameson Datacenter - Physical Architecture

See full-sized image.

Apparently the last time I updated this Visio diagram, I still hadn't decided what to do with all of the Dell servers I had procured through various channels (primarily the Dell Outlet and ebay). Hence the Dell PowerEdge 4300 with the "??" next to it. As I mentioned in my original post on the Jameson Datacenter, this server was the original BEAST (which is now my "Production" database server). However, it has since been replaced with a home-built server.

From the previous figure, you can start to see why I've consolidated these servers in recent years by leveraging virtualization. The power consumption by all of these servers was really rather ridiculous when you consider what I was using these servers for.

Notice that I use to run a back-to-back firewall configuration with a perimeter network (a.k.a. DMZ):

Figure 2: Old Jameson Datacenter - TCP/IP Configuration

See full-sized image.

This is because I had one server with a public (static) IP address and therefore ran a couple of Web sites on the old "ICEMAN" server -- hence the name "ICEMAN", because it was my "IIS" server. Get it? Yeah, I know...more geekiness.

The naming convention was such that the names corresponding to X-Men heroes were all members of the TECHTOOLBOX domain, whereas servers corresponding to X-Men villains were considered "dangerous" and thus not members of the domain. Egad! Does the geekness ever end?! [I wonder if someday when my daughter is much older, she'll ever bother to read this and seriously start to question her father's sanity.]

Anyway, here's the DNS and DHCP configuration for the original farm:

Figure 1: Old Jameson Datacenter - DNS/DHCP Configuration

See full-sized image.

There's nothing really too interesting about that, I suppose.

Perhaps the most laughable aspect of the Old Jameson Datacenter -- at least when compared to today -- was the storage infrastructure:

Figure 1: Old Jameson Datacenter - Disk Configuration

See full-sized image.

I can still remember when I thought the 18 GB of RAID1 and 72 GB of RAID5 on that Dell 4300 was fashizzle ;-) [Of course, that was long before I was even aware of the term "fashizzle", but you get my point.]

Anyway, I hope you enjoyed this brief diversion down Memory Lane. Perhaps it invoked some distant memories of your own experiences in the world of technology.

Personally, as I'm wrapping up this post, my head is spinning with thoughts of my father's original Apple II+ (which was the first computer I ever "programmed" on) as well as my very own Commodore 64 and all those late nights my dear friend Chris Gatewood and I sat in front of it typing in hundreds of lines of code from a magazine just so we could try to play some silly game based on "sprites." [Note that the games almost never worked due to some error or another, but nevertheless we kept trying anyway.]

Configure IntelliMirror Using Group Policy

Jeremy Jameson — Wed, 21 Oct 2009 12:57:00 GMT

Yet another Group Policy object that I use in the "Jameson Datacenter" (a.k.a. my home lab) is one to automatically configure roaming profiles and redirect the Desktop and Documents folders to a server(a.k.a. "IntelliMirror").

Even though I don't have many users in my Active Directory domain -- it's not like I have eight kids, just one -- I still want to keep user data centrally managed on a server that I backup regularly. Besides, I find it really frustrating to have some items on your desktop on one computer, but a different set of desktop items on another computer (or VM).

To automatically configure this in the "Jameson Datacenter", I defined a Group Policy (named Default User Data and Settings Policy) with the following settings:

User Configuration
- Policies
  - Windows Settings
    - Folder Redirection
      - AppData(Roaming)
        
        Setting: Basic (Redirect everyone's folder to the same location)
        
        Path: \\beast\Users$\%USERNAME%\Application Data
        
        Options
        
        Grant user exclusive rights to AppData(Roaming): Enabled
        
        Move the contents of AppData(Roaming) to the new location: Enabled
        
        Also apply redirection policy to Windows 2000, Windows 2000 server, Windows XP, and Windows Server 2003 operating systems: Enabled
        
        Policy Removal Behavior: Leave contents
      - Desktop
        
        Setting: Basic (Redirect everyone's folder to the same location)
        
        Path: \\beast\Users$\%USERNAME%\Desktop
        
        Options
        
        Grant user exclusive rights to Desktop: Enabled
        
        Move the contents of Desktop to the new location: Enabled
        
        Also apply redirection policy to Windows 2000, Windows 2000 server, Windows XP, and Windows Server 2003 operating systems: Enabled
        
        Policy Removal Behavior: Leave contents
      - Documents
        
        Setting: Basic (Redirect everyone's folder to the same location)
        
        Path: \\beast\Users$\%USERNAME%\Documents
        
        Options
        
        Grant user exclusive rights to Documents: Enabled
        
        Move the contents of Documentsto the new location: Enabled
        
        Also apply redirection policy to Windows 2000, Windows 2000 server, Windows XP, and Windows Server 2003 operating systems: Enabled
        
        Policy Removal Behavior: Leave contents
      - Music
        
        Setting: Follow the Documents folder
      - Pictures
        
        Setting: Follow the Documents folder
      - Videos
        
        Setting: Follow the Documents folder

Note

Those of you that have a very keen eye (and also a photographic memory) might recall that in a previous post, I listed BEAST as a database server (it is currently running SQL Server 2005). Yes, it's true, I'm breaking one of my own cardinal sins by having a SQL Server also serve as a file server. I don't recommend doing this unless, like me, you are trying to go as cheap as possible -- and, even then, only for a lab environment like mine.

In order to allow users access to create their own folders on \\BEAST\Users$, I have configured the following permissions on C:\BackedUp\Users:

Domain Users
- Apply onto: This folder only
- Permissions
  - List Folder / Read Data
  - Create Folders / Append Data
CREATOR OWNER
- Apply onto: Subfolders and files only
- Permissions
  - Full Control

I also created a hidden share for the C:\BackedUp\Users folder and granted Full Control to Authenticated Users (since the NTFS permissions above ultimately determine the level of access for all users).

Thus when a new user logs in for the first time, a corresponding folder is created on the server and all of the user's files are stored on the server.

Eliminate MBSA Warnings Using Default Security Settings Policy

Jeremy Jameson — Wed, 21 Oct 2009 11:57:00 GMT

Another Group Policy object that I use in the "Jameson Datacenter" (a.k.a. my home lab) is one that I created a couple of years ago in order to eliminate various warnings from the Microsoft Baseline Security Advisor (MBSA).

To automatically change the default security settings in the "Jameson Datacenter", I defined a Group Policy (named Default Security Settings Policy) with the following settings:

Computer Configuration
- Policies
  - Windows Settings
    - Security Settings
      - Account Policies
        
        Password Policy
        
        Maximum password age: 60 days
        
        Minimum password age: 1 day
        
        Minimum password length: 8 characters
      - Local Policies
        
        Security Options
        
        Network security: LAN Manager authentication level: Send NTLMv2 response only. Refuse LM & NTLM
      - System Services
        
        TlntSvr
        
        Startup Mode: Disabled

I don't know about you, but I haven't used Telnet in almost fifteen years -- back when I used to work on Unix systems ;-)

This Group Policy is linked to the entire domain (i.e. corp.technologytoolbox.com).

Note that I still use the Default Domain Controllers Policy to configure the security settings on the domain controllers (and thus domain accounts). In other words, the settings noted above only affect local accounts (e.g. COLOSSUS\Administrator, not TECHTOOLBOX\jjameson).

Add Rooler to Your Web Development Toolbox

Jeremy Jameson — Wed, 21 Oct 2009 10:19:00 GMT

This past May, one of my colleagues notified me of a new tool called "Rooler" that allows you to easily measure anything displayed on your screen.

I definitely consider this tool a "must have" for anyone out there doing Web development. While tools like Firebug and the new developer tools in Internet Explorer 8 are great for analyzing the layout of Web pages, I often find myself using Rooler when tweaking CSS rules in order to achieve that "pixel perfect" design. For example, yesterday I was working on styling the new customer service portal that I'm working on and I wanted to match the customer's current .com site. Rooler enabled me to identify the dimensions of the header and margins of various elements with almost no effort whatsoever.

If you haven't already discovered Rooler, I strongly recommend you download it today.

Introducing the SharePointSmtpHelper Class

Jeremy Jameson — Sun, 18 Oct 2009 14:29:00 GMT

Continuing in the spirit of my previous posts for the SharePointPublishingHelper class and SharePointWebPartHelper class, I'd like to introduce another helper class that you may find useful when building solutions for Windows SharePoint Services (WSS) v3 and Microsoft Office SharePoint Server (MOSS) 2007.

Consider the scenario where you need to send an e-mail message from a SharePoint application. Perhaps an unexpected error occurred and you want to notify the operations team, or perhaps you just want to send a confirmation message to a user who has just submitted some important information.

Whatever the case, you'd like to send an e-mail message using the SMTP server configured in SharePoint Central Administration for the farm. SharePointSmtpHelper makes it really easy to do this.

Note that there's really not much code to the SharePointSmtpHelper class -- thanks to the classes provided by the .NET Framework in the System.Net.Mail namespace. It may look like more code than you might expect, but that's just because of all the overloads of the SendMessage method that I provide.

using System;
using System.Net.Mail;

using Microsoft.SharePoint;
using Microsoft.SharePoint.Administration;

namespace Fabrikam.Demo.CoreServices.SharePoint
{
    /// <summary>
    /// Exposes static methods for sending e-mail messages from a SharePoint
    /// Web application using the Simple Mail Transfer Protocol (SMTP). The
    /// SMTP server must be configured in SharePoint Central Administration.
    /// This class cannot be inherited.
    /// </summary>
    /// <remarks>
    /// All methods of the <b>SharePointSmtpHelper</b> class are static and
    /// can therefore be called without creating an instance of the class.
    /// </remarks>
    public sealed class SharePointSmtpHelper
    {
        private static object lockObject = new object();

        private static string smtpServer;
        private static string defaultFromAddress;
        
        private SharePointSmtpHelper( ) { } // all members are static

        /// <summary>
        /// Sends an e-mail message using the outbound SMTP server and
        /// "From address" configured in SharePoint Central Administration.
        /// </summary>
        /// <param name="toRecipients">The recipients of the e-mail message.
        /// In other words, the addresses on the To line of the e-mail.</param>
        /// <param name="subject">The subject line for the e-mail message.
        /// </param>
        /// <param name="body">The e-mail message body.</param>
        public static void SendMessage(
            string toRecipients,
            string subject,
            string body)
        {
            SendMessage(
                toRecipients,
                subject,
                body,
                false,
                null,
                null);
        }

        /// <summary>
        /// Sends an e-mail message using the outbound SMTP server and
        /// "From address" configured in SharePoint Central Administration,
        /// specifying whether the body of the message is formatted using HTML.
        /// </summary>
        /// <param name="toRecipients">The recipients of the e-mail message.
        /// In other words, the addresses on the To line of the e-mail.</param>
        /// <param name="subject">The subject line for the e-mail message.
        /// </param>
        /// <param name="body">The e-mail message body.</param>
        /// <param name="isBodyHtml"><c>true</c> if the mail message body is
        /// formatted using HTML markup. <c>false</c> if the message is simply
        /// plain text.</param>
        public static void SendMessage(
            string toRecipients,
            string subject,
            string body,
            bool isBodyHtml)
        {
            SendMessage(
                toRecipients,
                subject,
                body,
                isBodyHtml,
                null,
                null);
        }

        /// <summary>
        /// Sends an e-mail message using the outbound SMTP server and
        /// "From address" configured in SharePoint Central Administration,
        /// specifying whether the body of the message is formatted using HTML
        /// and also including carbon copy (CC) recipients.
        /// </summary>
        /// <param name="toRecipients">The recipients of the e-mail message.
        /// In other words, the addresses on the To line of the e-mail.</param>
        /// <param name="subject">The subject line for the e-mail message.
        /// </param>
        /// <param name="body">The e-mail message body.</param>        
        /// <param name="isBodyHtml"><c>true</c> if the mail message body is
        /// formatted using HTML markup. <c>false</c> if the message is simply
        /// plain text.</param>
        /// <param name="ccRecipients">The carbon copy (CC) recipients of the
        /// e-mail message.</param>
        public static void SendMessage(
            string toRecipients,
            string subject,
            string body,
            bool isBodyHtml,
            string ccRecipients)
        {
            SendMessage(
                toRecipients,
                subject,
                body,
                isBodyHtml,
                ccRecipients,
                null);
        }

        /// <summary>
        /// Sends an e-mail message using the outbound SMTP server configured
        /// in SharePoint Central Administration for the farm.
        /// </summary>
        /// <param name="toRecipients">The recipients of the e-mail message.
        /// In other words, the addresses on the To line of the e-mail.</param>
        /// <param name="subject">The subject line for the e-mail message.
        /// </param>
        /// <param name="body">The e-mail message body.</param>        
        /// <param name="isBodyHtml"><c>true</c> if the mail message body is
        /// formatted using HTML markup. <c>false</c> if the message is simply
        /// plain text.</param>
        /// <param name="ccRecipients">The carbon copy (CC) recipients of the
        /// e-mail message.</param>
        /// <param name="from">The e-mail address of the sender.</param>
        public static void SendMessage(
            string toRecipients,
            string subject,
            string body,
            bool isBodyHtml,
            string ccRecipients,
            string from)
        {
            if (string.IsNullOrEmpty(toRecipients) == true)
            {
                throw new ArgumentNullException("toRecipients");
            }

            toRecipients = toRecipients.Trim();
            if (string.IsNullOrEmpty(toRecipients) == true)
            {
                throw new ArgumentException(
                    "In order to send an e-mail message, "
                        + " at least one recipient must be specified.",
                    "toRecipients");
            }

            if (string.IsNullOrEmpty(subject) == true)
            {
                throw new ArgumentNullException("subject");
            }

            subject = subject.Trim();
            if (string.IsNullOrEmpty(subject) == true)
            {
                throw new ArgumentException(
                    "In order to send an e-mail message, "
                        + " the subject must be specified.",
                    "subject");
            }

            if (string.IsNullOrEmpty(body) == true)
            {
                throw new ArgumentNullException("body");
            }

            body = body.Trim();
            if (string.IsNullOrEmpty(body) == true)
            {
                throw new ArgumentException(
                    "In order to send an e-mail message, "
                        + " the message body must be specified.",
                    "body");
            }

            EnsureSmtpSettings();

            // If the "from" address is not specified, default to the address
            // configured in SharePoint Central Administration.
            if (string.IsNullOrEmpty(from) == true)
            {
                from = defaultFromAddress;
            }

            SmtpClient smtpClient = new SmtpClient(smtpServer);

            MailMessage message = new MailMessage(
                from,
                toRecipients,
                subject,
                body);

            message.IsBodyHtml = isBodyHtml;

            if (string.IsNullOrEmpty(ccRecipients) == false)
            {
                message.CC.Add(ccRecipients);
            }

            smtpClient.Send(message);
        }

        private static void EnsureSmtpSettings()
        {
            if (string.IsNullOrEmpty(smtpServer) == true)
            {
                if (SPContext.Current == null)
                {
                    throw new InvalidOperationException(
                        "SharePointSmtpClient can only be called from within"
                            + " a SharePoint site (SPContext.Current is null).");
                }

                lock (lockObject)
                {
                    if (string.IsNullOrEmpty(smtpServer) == true)
                    {
                        SPWebApplication webApp =
                            SPContext.Current.Site.WebApplication;

                        if (webApp.OutboundMailServiceInstance != null
                            && webApp.OutboundMailServiceInstance.Server != null)
                        {
                            smtpServer =
                                webApp.OutboundMailServiceInstance.Server.Address;
                        }

                        if (string.IsNullOrEmpty(smtpServer) == true)                            
                        {
                            throw new InvalidOperationException(
                                "The outbound SMTP server is not specified in"
                                + " SharePoint Central Administration.");
                        }

                        defaultFromAddress = webApp.OutboundMailSenderAddress;
                    }
                }
            }
        }
    }
}

Note that I use static members in order to only read the SMTP server configuration from SharePoint Central Administration one time.

Assuming you just want to send a simple message using the default "From address" specified in SharePoint Central Administration, you only need a single line of code that passes three parameters:

            SharePointSmtpHelper.SendMessage(
                "jeremy_jameson@fabrikam.com",
                "Test message",
                "Testing the SharePointSmtpHelper class");

Introducing the SharePointWebPartHelper Class

Jeremy Jameson — Sat, 17 Oct 2009 12:54:00 GMT

In a previous post, I introduced the DR.DADA approach to SharePoint development and how I typically use the concept of a FeatureConfigurator to automatically configure one or more aspects of a SharePoint site when activating my feature.

For example, on my latest project, we needed a login page as well as a legal disclaimer page for a customer service portal based on Microsoft Office SharePoint Server (MOSS) 2007. Thus I created a "PublicSiteConfiguration" feature that, upon activation:

Automatically creates the /Public site
Populates the page content on the /Public/Pages/default.aspx page and adds an instance of a custom Login Form Web Part to the page
Creates the /Public/Pages/Disclaimer.aspx page and populates its default content

I've already introduced the SharePointPublishingHelper class that performs the bulk of the work in creating and configuring publishing pages. In this post, I want to cover the SharePointWebPartHelper class. Like the SharePointPublishingHelper class, the SharePointWebPartHelper class is simply a collection of helper methods for the SharePoint API.

SharePointWebPartHelper makes it really easy to:

Attempt to retrieve a reference to a Web Part by specifying an SPLimitedWebPartManager for a specific page and the title of the Web Part you are trying to find
Ensure a Web Part exists on a page (creating a new Web Part as necessary)
Ensuring a ContentEditorWebPart exists on a page and that it is configured with the specified HTML content and title (as well as removing the "chrome", since -- at least in my experience -- you don't want to show this to users for this type of Web Part)

Note that one could argue that the stuff specific to the Content Editor Web Part doesn't really belong in this class, but nevertheless that's where it ended up after refactoring the code a few years ago on the Agilent Technologies project. [Actually, I believe it originally ended up in an even more generic SharePointHelper class, but I've since refactored it even further into the SharePointWebPartHelper class.]

Anyway, here's the code for the SharePointWebPartHelper class:

using System;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Security.Permissions;
using System.Web.UI.WebControls.WebParts;
using System.Xml;

using Microsoft.SharePoint;
using Microsoft.SharePoint.Security;
using SPWebPartPages = Microsoft.SharePoint.WebPartPages;

using Fabrikam.Demo.CoreServices.Logging;

namespace Fabrikam.Demo.CoreServices.SharePoint
{
    /// <summary>
    /// Exposes static methods for commonly used helper functions for
    /// SharePoint Web Parts. This class cannot be inherited.
    /// </summary>
    /// <remarks>
    /// All methods of the <b>SharePointWebPartHelper</b> class are static and
    /// can therefore be called without creating an instance of the class.
    /// </remarks>
    [CLSCompliant(false)]
    [SharePointPermission(SecurityAction.LinkDemand, ObjectModel = true)]
    public sealed class SharePointWebPartHelper
    {
        private SharePointWebPartHelper() { } // all members are static

        private static WebPart CreateWebPart(
            SPWebPartPages.SPLimitedWebPartManager wpm,
            string webPartId,
            string webPartFilename,
            string zoneId,
            ref int zoneIndex)
        {
            Debug.Assert(wpm != null);
            Debug.Assert(string.IsNullOrEmpty(webPartId) == false);
            Debug.Assert(string.IsNullOrEmpty(webPartFilename) == false);
            Debug.Assert(string.IsNullOrEmpty(zoneId) == false);

            Logger.LogDebug(
                CultureInfo.InvariantCulture,
                "Creating Web Part ({0}) on page ({1})...",
                webPartId,
                wpm.ServerRelativeUrl);

            WebPart webPart = null;

            SPFile wpFile = GetWebPartFileFromGallery(
                wpm.Web.Site,
                webPartFilename);

            Debug.Assert(wpFile != null);

            string errorMessage = string.Empty;

            using (Stream stream = wpFile.OpenBinaryStream())
            {
                XmlReader reader = XmlReader.Create(stream);
                webPart = wpm.ImportWebPart(reader, out errorMessage);
            }

            if (string.IsNullOrEmpty(errorMessage) == false)
            {
                string message =
                    "Error importing Web Part ("
                        + webPartFilename + "): "
                        + errorMessage;

                throw new SPWebPartPages.WebPartPageUserException(message);
            }

            webPart.ID = webPartId;
            wpm.AddWebPart(webPart, zoneId, zoneIndex);

            // HACK: When adding the first, second, third, and fourth Web Parts
            // to a zone:
            //
            //    SPLimitedWebPartManager.AddWebPart(webPart, zoneId, zoneIndex)
            //
            // behaves as expected, meaning that
            // (webPart.ZoneIndex == zoneIndex).
            //
            // However, when adding the fifth and sixth Web Parts to a zone,
            // then (webPart.ZoneIndex == zoneIndex + 1).
            if (webPart.ZoneIndex > zoneIndex)
            {
                Debug.Assert(zoneIndex >= 4);

                Logger.LogDebug(
                    CultureInfo.InvariantCulture,
                    "HACK: webPart.ZoneIndex ({0})"
                        + " is greater than zoneIndex ({1})."
                        + " Setting zoneIndex to {0}...",
                    webPart.ZoneIndex,
                    zoneIndex);

                zoneIndex = webPart.ZoneIndex;
            }

            Debug.Assert(webPart.ZoneIndex == zoneIndex);
            zoneIndex++;
            
            Logger.LogInfo(
                CultureInfo.InvariantCulture,
                "Successfully created Web Part ({0}) on page ({1}).",
                webPartId,
                wpm.ServerRelativeUrl);

            return webPart;
        }

        /// <summary>
        /// Ensures that a specific Web Part exists on a page.
        /// </summary>
        /// <param name="wpm">The Web Part manager for the page.</param>
        /// <param name="webPartId">The unique identifier for the Web Part.</param>
        /// <param name="webPartFileName">The .dwp or .webpart file in the
        /// Web Part gallery (used to import the Web Part if it does not exist).
        /// </param>
        /// <param name="zoneId">The zone the Web Part should reside in.</param>
        /// <param name="zoneIndex">The index of the Web Part relative to other
        /// Web Parts in the zone. If the Web Part is created, the index is
        /// incremented.</param>
        /// <returns>The new or existing Web Part on the page.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage(
            "Microsoft.Design",
            "CA1045:DoNotPassTypesByReference",
            Justification = "The zoneIndex is incremented when the Web Part is"
                + " added.")]
        public static WebPart EnsureWebPart(
            SPWebPartPages.SPLimitedWebPartManager wpm,
            string webPartId,
            string webPartFileName,
            string zoneId,
            ref int zoneIndex)
        {
            if (wpm == null)
            {
                throw new ArgumentNullException("wpm");
            }

            if (string.IsNullOrEmpty(webPartId) == true)
            {
                throw new ArgumentException(
                    "The Web Part Id must be specified.",
                    "webPartId");
            }

            if (string.IsNullOrEmpty(webPartFileName) == true)
            {
                throw new ArgumentException(
                    "The Web Part file name must be specified.",
                    "webPartFileName");
            }

            if (string.IsNullOrEmpty(zoneId) == true)
            {
                throw new ArgumentException(
                    "The Web Part zone must be specified.",
                    "zoneId");
            }

            WebPart webPart = wpm.WebParts[webPartId];

            if (webPart == null)
            {
                webPart = CreateWebPart(wpm, webPartId, webPartFileName,
                    zoneId, ref zoneIndex);
            }
            else
            {
                // HACK: webPart.Zone appears to always be null (SharePoint bug?)
                if (webPart.Zone == null)
                {
                    Logger.LogDebug(
                        CultureInfo.InvariantCulture,
                        "Unable to check zone for Web Part ({0})"
                            + " because webPart.Zone is null.",
                        webPartId);
                }
                else if (webPart.Zone.ID != zoneId)
                {
                    Logger.LogDebug(
                        CultureInfo.InvariantCulture,
                        "Moving Web Part ({0}) to zone ({1})...",
                        webPartId,
                        zoneId);

                    wpm.MoveWebPart(webPart, zoneId, zoneIndex);
                    wpm.SaveChanges(webPart);

                    Logger.LogInfo(
                        CultureInfo.InvariantCulture,
                        "Successfully moved Web Part ({0}) to zone ({1}).",
                        webPartId,
                        zoneId);
                }
            }

            return webPart;
        }

        /// <summary>
        /// Finds the first Web Part with the specified title.
        /// </summary>
        /// <remarks>
        /// This is useful in cases where the Web Part ID is not specified
        /// when it was added to the collection of Web Parts (thus generating
        /// a random identifier and making SPLimitedWebPartCollection[id]
        /// effectively useless).
        /// </remarks>
        /// <param name="wpm">The Web Part manager for the page.</param>
        /// <param name="webPartTitle">The title of the Web Part to find.</param>
        /// <returns>A Web Part object (if one is found), otherwise null.</returns>
        public static WebPart FindWebPartByTitle(
            SPWebPartPages.SPLimitedWebPartManager wpm,
            string webPartTitle)
        {
            if (wpm == null)
            {
                throw new ArgumentNullException("wpm");
            }

            if (string.IsNullOrEmpty(webPartTitle) == true)
            {
                throw new ArgumentException(
                    "The Web Part title must be specified.",
                    "webPartTitle");
            }

            Logger.LogDebug(
                CultureInfo.InvariantCulture,
                "Attemping to find Web Part ({0}) on page ({1})...",
                webPartTitle,
                wpm.ServerRelativeUrl);

            for (int i = 0; i < wpm.WebParts.Count; i++)
            {
                WebPart webPart = wpm.WebParts[i];

                if (string.Compare(
                        webPart.Title,
                        webPartTitle,
                        StringComparison.OrdinalIgnoreCase) == 0)
                {
                    Logger.LogDebug(
                        CultureInfo.InvariantCulture,
                        "Found Web Part ({0}) on page ({1}).",
                        webPartTitle,
                        wpm.ServerRelativeUrl);

                    return webPart;
                }
            }

            Logger.LogDebug(
                CultureInfo.InvariantCulture,
                "Unable to find Web Part ({0}) on page ({1}).",
                webPartTitle,
                wpm.ServerRelativeUrl);

            return null;
        }

        private static SPFile GetWebPartFileFromGallery(
            SPSite site,
            string webPartFilename)
        {
            if (site == null)
            {
                throw new ArgumentNullException("site");
            }

            if (webPartFilename == null)
            {
                throw new ArgumentNullException("webPartFilename");
            }

            webPartFilename = webPartFilename.Trim();
            if (string.IsNullOrEmpty(webPartFilename))
            {
                throw new ArgumentException(
                    "The Web Part filename must be specified.",
                    "webPartFilename");
            }

            Logger.LogDebug(
                CultureInfo.InvariantCulture,
                "Getting Web Part file ({0}) from site ({1}) gallery...",
                webPartFilename,
                site.Url);

            SPList wpGallery = site.GetCatalog(SPListTemplateType.WebPartCatalog);

            string camlQuery = "<Where><Eq><FieldRef Name=\"FileLeafRef\" />"
                + "<Value Type=\"File\">" + webPartFilename + "</Value></Eq></Where>";

            SPQuery query = new SPQuery();
            query.Query = camlQuery;

            SPListItemCollection webParts = wpGallery.GetItems(query);
            if (webParts.Count == 0)
            {
                string message = string.Format(
                    CultureInfo.InvariantCulture,
                    "Web Part ({0}) was not found in the Web Part Gallery.",
                    webPartFilename);
                
                throw new ArgumentException(
                    message,
                    "webPartFilename");
            }

            Logger.LogDebug(
                CultureInfo.InvariantCulture,
                "Found Web Part file ({0}) in site ({1}) gallery.",
                webPartFilename,
                site.Url);

            Debug.Assert(webParts.Count == 1);
            return webParts[0].File;
        }

        /// <summary>
        /// Ensures that a Content Editor Web Part exists on a page
        /// and is configured with the specified settings.
        /// </summary>
        /// <param name="wpm">The Web Part manager for the page.</param>
        /// <param name="webPartId">The unique identifier for the Web Part.</param>
        /// <param name="zoneId">The zone the Web Part should reside in.</param>
        /// <param name="zoneIndex">The index of the Web Part relative to other
        /// Web Parts in the zone. If the Web Part is created, the index is
        /// incremented.</param>
        /// <param name="htmlContent">The content to display within the Web
        /// Part.</param>
        /// <param name="title">The title of the Web Part.</param>
        /// <returns>The new or existing Web Part on the page.</returns>        
        [System.Diagnostics.CodeAnalysis.SuppressMessage(
            "Microsoft.Design",
            "CA1045:DoNotPassTypesByReference",
            Justification="The zoneIndex is incremented when the Web Part is"
                + " added.")]
        public static SPWebPartPages.ContentEditorWebPart
            EnsureContentEditorWebPart(
                SPWebPartPages.SPLimitedWebPartManager wpm,
                string webPartId,
                string zoneId,
                ref int zoneIndex,
                string htmlContent,
                string title)
        {
            if (wpm == null)
            {
                throw new ArgumentNullException("wpm");
            }

            if (webPartId == null)
            {
                throw new ArgumentNullException("webPartId");
            }

            webPartId = webPartId.Trim();
            if (string.IsNullOrEmpty(webPartId))
            {
                throw new ArgumentException(
                    "The Web Part ID must be specified.",
                    "webPartId");
            }

            if (zoneId == null)
            {
                throw new ArgumentNullException("zoneId");
            }

            zoneId = zoneId.Trim();
            if (string.IsNullOrEmpty(zoneId))
            {
                throw new ArgumentException(
                    "The Web Part zone must be specified.",
                    "zoneId");
            }

            if (htmlContent == null)
            {
                throw new ArgumentNullException("htmlContent");
            }

            htmlContent = htmlContent.Trim();
            if (string.IsNullOrEmpty(htmlContent))
            {
                throw new ArgumentException(
                    "The HTML content must be specified.",
                    "htmlContent");
            }

            // Note: title is optional

            Logger.LogDebug(
                CultureInfo.InvariantCulture,
                "Ensuring Content Editor Web Part ({0}) on page ({1})...",
                webPartId,
                wpm.ServerRelativeUrl);

            SPWebPartPages.ContentEditorWebPart webPart =
                (SPWebPartPages.ContentEditorWebPart) EnsureWebPart(
                    wpm,
                    webPartId,
                    "MSContentEditor.dwp",
                    zoneId,
                    ref zoneIndex);

            if (webPart.Content == null
                || webPart.Content.InnerText != htmlContent
                || webPart.Title != title
                || webPart.ChromeType != PartChromeType.None)
            {
                Logger.LogDebug(
                    CultureInfo.InvariantCulture,
                    "Updating properties of Content Editor Web Part ({0}) on"
                        + " page ({1})...",
                    webPartId,
                    wpm.ServerRelativeUrl);

                // To bring content into the Content Editor Web Part,
                // we need to use an XML Document
                XmlDocument xmlDoc = new XmlDocument();
                XmlElement xmlElement = xmlDoc.CreateElement("HtmlContent");
                xmlElement.InnerText = htmlContent;
                webPart.Content = xmlElement;

                webPart.Title = title;
                webPart.ChromeType = PartChromeType.None;

                wpm.SaveChanges(webPart);

                Logger.LogInfo(
                    CultureInfo.InvariantCulture,
                    "Successfully updated properties of Content Editor Web Part"
                        + " ({0}) on page ({1}).",
                    webPartId,
                    wpm.ServerRelativeUrl);
            }
            else
            {
                Logger.LogDebug(
                    CultureInfo.InvariantCulture,
                    "The Content Editor Web Part ({0}) on page ({1}) is already"
                        + " configured with the expected settings.",
                    webPartId,
                    wpm.ServerRelativeUrl);
            }

            return webPart;
        }
    }
}

Most of the code in the SharePointWebPartHelper class is very straightforward. The most interesting hack -- er, I mean workaround -- in the code is to handle the scenario where the zoneIndex is sometimes mysteriously incremented by more than one, but you can read more about this in a previous post -- if you are really interested.

Using the SharePointWebPartHelper class couldn't be easier. For a simple example, consider the scenario that I mentioned earlier about adding a Login Form Web Part to a page:

            // Configure Web Parts
            SPWebPartPages.SPLimitedWebPartManager wpm =
                publicWeb.GetLimitedWebPartManager(
                    page.Url,
                    PersonalizationScope.Shared);

            using (wpm)
            {
                string zoneId = "LeftColumnZone";
                int zoneIndex = 0;

                LoginFormWebPart loginForm =
                    (LoginFormWebPart) SharePointWebPartHelper.EnsureWebPart(
                        wpm,
                        "LoginForm",
                        "Fabrikam_LoginForm.webpart",
                        zoneId,
                        ref zoneIndex);

                loginForm.DisplayRememberMe = false;
                wpm.SaveChanges(loginForm);

                // HACK: Avoid memory leak in SPLimitedWebPartManager
                if (wpm.Web != null)
                {
                    wpm.Web.Dispose();
                }
            }

Just be sure to avoid the memory leak in SPLimitedWebPartManager, like I show in the code example above.

Here's another code example where I configured a bunch of Web Parts on a search results page:

namespace Fabrikam.Web.Search.Configuration
{
    /// <summary>
    /// Exposes static methods for configuring the <b>Fabrikam.Web.Search</b>
    /// feature. This class cannot be inherited.
    /// </summary>
    /// <remarks>
    /// All methods of the <b>FeatureConfigurator</b> class are static and can
    /// therefore be called without creating an instance of the class.
    /// </remarks>  
    [CLSCompliant(false)]
    [SharePointPermission(SecurityAction.LinkDemand, ObjectModel = true)]
    public sealed class FeatureConfigurator
    {
        ...

        private static void ConfigureSearchResultsPageWebParts(
            SPWeb searchWeb,
            PublishingPage searchResultsPage,
            string defaultSearchResultsPageUrl,
            string scopeName,
            string additionalQueryTerms,
            string contextualScopeUrl)
        {
            SPWebPartPages.SPLimitedWebPartManager wpm =
                searchWeb.GetLimitedWebPartManager(
                    searchResultsPage.Url, PersonalizationScope.Shared);

            using (wpm)
            {
                #region Zone1

                string zoneId = "Zone1";
                int zoneIndex = 0;

                SharePointWebPartHelper.EnsureContentEditorWebPart(
                    wpm,
                    "startNewSearchHeading",
                    zoneId,
                    ref zoneIndex,
                    "<h2 class='accent3'>Start a new search</h2>",
                    "Start New Search Heading");

                SearchBoxEx searchBox =
                    (SearchBoxEx)SharePointWebPartHelper.EnsureWebPart(
                        wpm,
                        "searchBox",
                        "SearchBox.dwp",
                        zoneId,
                        ref zoneIndex);

                searchBox.DropDownModeEx = DropDownModesEx.HideScopeDD;
                searchBox.SearchResultPageURL = defaultSearchResultsPageUrl;
                searchBox.Width = string.Empty;

                wpm.SaveChanges(searchBox);

                SharePointWebPartHelper.EnsureContentEditorWebPart(
                    wpm,
                    "refineSearchHeading",
                    zoneId,
                    ref zoneIndex,
                    "<h2 class='accent3'>Refine your search</h2>",
                    "Refine Search Heading");

                FabrikamSearchBoxWebPart searchScopeOptions =
                    (FabrikamSearchBoxWebPart)SharePointWebPartHelper.EnsureWebPart(
                        wpm,
                        "searchScopeOptions",
                        "FabrikamSearchBox.webpart",
                        zoneId,
                        ref zoneIndex);

                searchScopeOptions.ShowSearchBox = false;
                wpm.SaveChanges(searchScopeOptions);

                ConfigureFacetedSearchWebParts(
                    wpm,
                    zoneId,
                    ref zoneIndex,
                    scopeName);

                #endregion
                
                #region Zone2

                zoneId = "Zone2";
                zoneIndex = 0;

                SharePointWebPartHelper.EnsureWebPart(
                    wpm,
                    "searchTabs",
                    "FabrikamListBoundTabStrip.webpart",
                    zoneId,
                    ref zoneIndex);

                SharePointWebPartHelper.EnsureWebPart(
                    wpm,
                    "searchSummary",
                    "SearchSummary.dwp",
                    zoneId,
                    ref zoneIndex);

                bool showBestBetsWebPart = false;

                if (string.Compare(
                    searchResultsPage.Name,
                    "Results.aspx",
                    StringComparison.OrdinalIgnoreCase) == 0)
                {
                    showBestBetsWebPart = true;
                }
                else if (string.Compare(
                    searchResultsPage.Name,
                    "AllSitesResults.aspx",
                    StringComparison.OrdinalIgnoreCase) == 0)
                {
                    showBestBetsWebPart = true;
                }

                if (showBestBetsWebPart == true)
                {
                    ConfigureBestBetsWebPartForSiteSearch(
                        wpm,
                        zoneId,
                        ref zoneIndex);
                }

                SearchStatsWebPart searchStats =
                    (SearchStatsWebPart) SharePointWebPartHelper.EnsureWebPart(
                        wpm,
                        "searchStats",
                        "searchStats.dwp",
                        zoneId,
                        ref zoneIndex);

                searchStats.DisplayResponseTime = false;
                wpm.SaveChanges(searchStats);
                
                SharePointWebPartHelper.EnsureWebPart(
                    wpm,
                    "searchPaging1",
                    "SearchPaging.dwp",
                    zoneId,
                    ref zoneIndex);

                ConfigureCoreResultsWebPartsForSiteSearch(
                    wpm,
                    zoneId,
                    ref zoneIndex,
                    scopeName);

                SharePointWebPartHelper.EnsureWebPart(
                    wpm,
                    "searchPaging2",
                    "SearchPaging.dwp",
                    zoneId,
                    ref zoneIndex);

                if (additionalQueryTerms != null
                    || contextualScopeUrl != null)
                {
                    ConfigureCoreResultsExtensionWebPart(
                        wpm,
                        additionalQueryTerms,
                        contextualScopeUrl,
                        zoneId,
                        ref zoneIndex);
                }

                #endregion
                
                // HACK: Avoid memory leak in SPLimitedWebPartManager
                if (wpm.Web != null)
                {
                    wpm.Web.Dispose();
                }
            }
        }
    }
}

Even though I didn't add any comments to this (rather lengthy) method, I think you'll find it is actually very easy to understand simply by reading the method names and parameters -- or at least that's what I hope for the people that are actually maintaining this code from my previous project ;-)

I hope you find the SharePointPublishingHelper and SharePointWebPartHelper classes as useful as I have over the past several years.

Be sure to stay tuned, because there are more SharePoint helper classes to come, but my daughter just woke up and now I need to go make some pancakes!

Event ID 10016, KB 920783, and the WSS_WPG Group

Jeremy Jameson — Sat, 17 Oct 2009 11:33:00 GMT

If you've ever deployed Windows SharePoint Services (WSS) v3 or Microsoft Office SharePoint Server (MOSS) 2007 in a least privilege configuration, you have undoubtedly encountered errors similar to the following in your Windows event log:

The application-specific permission settings do not grant Local Activation permission for the COM Server application with CLSID {61738644-F196-11D0-9953-00C04FD919C1} to the user TECHTOOLBOX\svc-sharepoint-dev SID (S-1-5-21-3914637029-2275272621-3670275343-1145) from address LocalHost (Using LRPC). This security permission can be modified using the Component Services administrative tool.

Specifically, I am referring to Event ID 10016 and 10017.

While these errors are apparently benign, it is still rather annoying to have your event logs flooded with this kind of "noise." [Personally, I very much like to see servers come up "clean" after a reboot (meaning no new errors or warnings in the event log). This is especially true when you use something like Systems Center Operations Manager (SCOM) to monitor your servers, and one or more members of the Operations team receives notification whenever an error occurs on a Production server.]

There are lots of sources out on the Internet that provide the steps necessary to resolve these errors (essentially you need to grant the SharePoint service account Local Activation permission to the IIS WAMREG Admin Service).

This week, I was glad to discover that Microsoft has a KnowledgeBase article (KB 920783) describing the errors and the associated workaround. [This KB article appears to have been published over two years ago, but honestly, I was completely unaware of it until just yesterday when I was building out the Production MOSS 2007 environment on my latest project.]

However, I see two problems with KB 920783:

First, it doesn't mention Microsoft Office SharePoint Server (MOSS) 2007 -- which might explain why I never came across this KB before when searching the Internet. Sure, we all know that MOSS 2007 is built on top of WSS v3 and thus KB articles that apply to "Microsoft Windows SharePoint Services 3.0" almost always apply to "Microsoft Office SharePoint Server 2007", but if you don't specifically state that, you shouldn't expect Bing or Google to return the KB article when searching for something like "MOSS 10016" or "Microsoft Office SharePoint Server 10016". Right?
Second, and much more important, the KB article instructs you to:

"type the domain user account that you specified as the Windows SharePoint Services 3.0 service account"

I definitely don't recommend doing that -- unless you just like making more work for yourself than necessary. Instead, you should specify the local WSS_WPG group rather than a specific user. This is what I've been doing for the last couple of years so trust me, it works.

The reason why I recommend using the "Windows SharePoint Services Worker Process Group" instead of individual users is that you are likely (or at least hopefully) using different service accounts for your SharePoint farm (e.g. TECHTOOLBOX\svc-sharepoint) and for the application pools behind your Web applications (e.g. TECHTOOLBOX\svc-web-fabrikam). Furthermore, if you are doing a large enterprise deployment of SharePoint, you likely have multiple Web applications (e.g. SSP, My Sites, etc.) that each utilize a separate service account.

Rather than granting the Local Activation permission to each of these service accounts individually, it is much more effective to just grant the permission to the WSS_WPG group instead.

Note

When creating a new Web application, SharePoint automatically adds the corresponding service account to the local WSS_WPG group on each SharePoint server in your farm.

[Update (2009-10-29):

Matt McEvoy contacted me last Monday regarding the fact that I didn't specify the WSS_ADMIN_WPG group -- only the WSS_WPG group.

Ugh...that will teach me to try to recall something like this from memory. When I was writing this blog post, I mistakenly thought that the service account for the SharePoint farm was added to both WSS_ADMIN_WPG and WSS_WPG. However, this isn't the case.

Therefore you need to be sure to apply the steps in KB 920783 using both groups if you want to rid your event logs of these errors once and for all. Again, this is assuming you are using least privilege accounts -- which I certainly hope you are.

Thanks, Matt, for pointing out my omission.]

Managing Group Membership via Group Policy - Part 2

Jeremy Jameson — Thu, 15 Oct 2009 13:04:00 GMT

In Part 1 of this post, I explained the Group Policy object (named Development - Restricted Groups Policy) that I use for enforcing group membership on a specific set of servers. As a follow-up to that post, I also want to cover an alternate method of managing group membership.

In the previous scenario -- i.e. ensuring that Development team leads always have administrative access to servers in their Development Integration Environment (DEV) -- we actually wanted to restrict the members of the local Administrators group on all servers in DEV. However, what if we need to address a slightly different scenario in which we want a specific user or group to always be a member of the local Administrators group -- in addition to other group members (that vary by server)?

For example, consider the fact that I use Systems Center Operations Manager (SCOM) in order to monitor the various physical and virtual servers in the the "Jameson Datacenter" (a.k.a. my home lab). One of the things I learned while deploying SCOM is that it is, um, challenging to deploy it in a least privilege configuration -- or at least for someone who primarily considers himself an AppDev (Application Development) flavor of Microsoft consultant.

At a bare minimum, your SCOM service account needs to be a member of the Performance Monitor Users group on each monitored server. Rather than forcing myself to configure this on all of my existing servers as well on new servers and VMs that I will undoubtedly add in the future, I decided to apply this change using Group Policy instead.

However, in this scenario, I don't want to restrict the members of the Performance Monitor Users group on each monitored server. Rather I simply want to ensure that the SCOM service account is a member of this group in addition to any other members.

To address this scenario, I created a startup script called EnsureLocalGroupMembership.cmd in the following folder:

file://corp.technologytoolbox.com/SysVol/corp.technologytoolbox.com/Policies/{GUID}/Machine/Scripts/Startup/OperationsManager

The contents of the script are actually quite trival:

net localgroup "Performance Monitor Users" TECHTOOLBOX\svc-mom-action /add

Note

Prior to deploying SCOM 2007 in the "Jameson Datacenter" I used its predecessor -- Microsoft Operations Manager (MOM) -- and thus had already created a service account named svc-mom-action.

To force this startup script to run on all monitored servers, I created a Group Policy object (named Default Operations Manager Policy) and linked it to the corresponding OU.

Here are the settings for the Group Policy:

Computer Configuration
- Policies
  - Windows Settings
    - Scripts (Startup/Shutdown)
      - Startup
        
        Name: OperationsManager\EnsureLocalGroupMembership.cmd

By linking this Group Policy to the appropriate OU (i.e. IT/Resources/Servers) the SCOM service account is ensured to be a member of the local Performance Monitor Users group on each monitored server. Voilà!