The Right Stuff

Importing Subversion Repositories to Google Code

Alexander Groß — Mon, 12 May 2008 13:19:04 GMT

I recently added two of my pet projects to Google Code. I chose Google's Open Source hosting because they have a very clean UI with integrated issue tracking and also offer native support for Subversion. One of the many aspects that make Subversion a decent choice is the ability to import existing SVN repositories to Google Code. That is, the whole history is uploaded and your soon-to-be open source project doesn't loose valuable undo history. YAGNI? Maybe.

Importing a complete repository to Google Code is well documented, but what if your repository contains several projects and you just want to upload a certain one? Actually Subversion has all you need, there are just a couple of things to prepare. I will provide everything you need here, you may also want to use this excellent write-up (also look here) which I used as a reference. The syntax presented here works on Windows, whereas the author of the above articles was working on a *nix machine, so the command lines differ a bit.

Create your Google Code project and reset the Subversion repository to revision 0

After you created the project on Google Code you can find the "Reset Subversion Repository" link at the bottom of the "Source" tab.

Prepare your Subversion repository

You need local access to the Subversion server, a Remote Desktop or SSH connection would suffice. I'm assuming your repository is accessible over HTTPS on port 8443. Here are the paths used in the command lines below:

Property	Value
SVN repositories root	C:\Subversion\
SVN repository containing the project	C:\Subversion\projects
Repository URL	https://localhost:8443/svn/projects/
Project to import to Google Code	https://localhost:8443/svn/projects/foo/Project-FooBar/
Google Code Subversion URL	https://project-foobar.googlecode.com/svn/

Dump your repository filtering the project path

First you need to dump the SVN repository containing the project in question. svnadmin dump saves the contents of the repository to the C:\Subversion\project-foobar.dump file on disk. To only take the parts into account we're interested in, use svndumpfilter to exclude everything outside the project path.

Renumbering revisions and dropping empty revisions cleans up the resulting dump and prevents revisions with no changes.

svnadmin dump C:\Subversion\projects\ | svndumpfilter --drop-empty-revs --renumber-revs include /foo/Project-FooBar/ > C:\Subversion\project-foobar.dump

Including (and dropping empty revisions for) prefixes:
   'foo/Project-FooBar'

* Dumped revision 0.
Revision 0 committed as 0.
* Dumped revision 1.
Revision 1 skipped.
...

Create a new repository for the project

Now that you have dump in place, create a new repository for Project-FooBar.

svnadmin create C:\Subversion\project-foobar-import

Create directories needed to load the dump

To make the import process succeed, you have to create the paths that are not included in the dump, i.e. all directories above the path that was included by svndumpfilter. In the our case, this is the /foo directory.

svn mkdir https://localhost:8443/svn/project-foobar-import/foo/ -m "Folder created for import"

Committed revision 1.

Load the filtered dump

It's time to import the dump to the repository just created.

svnadmin load C:\Subversion\project-foobar-import < C:\Subversion\project-foobar.dump

<<< Started new transaction, based on original revision 1
     * adding path : foo/Project-FooBar ... done.
     * adding path : foo/Project-FooBar/trunk ... done.
...

If you didn't create all necessary directories in the last step, you will receive an error message like this:

<<< Started new transaction, based on original revision 1
     * adding path : foo/Project-FooBar ...svnadmin: File not found: transaction '1-1', path 'foo/Project-FooBar'

Move directories such that they follow the standard Subversion directory structure

Your can now have a look at the new repository by pointing your browser to https://localhost:8443/svn/project-foobar-import/ where you only should see Project-FooBar.

The next step moves the project to the root of the repository and aligns the directory structure with Subversion's default directory layout.

svn move https://localhost:8443/svn/project-foobar-import/foo/Project-FooBar/trunk/ https://localhost:8443/svn/project-foobar-import/trunk/ -m "Folder moved"
svn move https://localhost:8443/svn/project-foobar-import/foo/Project-FooBar/tags/ https://localhost:8443/svn/project-foobar-import/tags/ -m "Folder moved"
svn move https://localhost:8443/svn/project-foobar-import/foo/Project-FooBar/branches/ https://localhost:8443/svn/project-foobar-import/branches/ -m "Folder moved"
svn delete https://localhost:8443/svn/project-foobar-import/foo/Project-FooBar/ -m "Folder deleted"

Upload your Subversion repository to Google Code using svnsync

All set. The last step is to upload your Subversion repository to Google Code using the documented command line below.

svnsync init https://project-foobar.googlecode.com/svn/ https://localhost:8443/svn/project-foobar-import/
Copied properties for revision 0.

svnsync sync https://project-foobar.googlecode.com/svn/
Committed revision 1.
Copied properties for revision 1.
...

The whole import process will take a little bit, depending on the size of your repository. It took me about 40 minutes for a repository with about 100 revisions, time to grab a cup of coffee.

The script

Of course you can script the whole process:

@rem Create dump
svnadmin dump C:\Subversion\projects\ | svndumpfilter --drop-empty-revs --renumber-revs include /foo/Project-FooBar/ > C:\Subversion\project-foobar.dump

@rem Create repository for import
svnadmin create C:\Subversion\project-foobar-import

@rem Create directories needed for the import to succeed
svn mkdir https://localhost:8443/svn/project-foobar-import/foo/ -m "Folder created for import"

@rem Load dump
svnadmin load C:\Subversion\project-foobar-import < C:\Subversion\project-foobar.dump

@rem Move folders around
svn move https://localhost:8443/svn/project-foobar-import/foo/Project-FooBar/trunk/ https://localhost:8443/svn/project-foobar-import/trunk/ -m "Folder moved"
svn move https://localhost:8443/svn/project-foobar-import/foo/Project-FooBar/tags/ https://localhost:8443/svn/project-foobar-import/tags/ -m "Folder moved"
svn move https://localhost:8443/svn/project-foobar-import/foo/Project-FooBar/branches/ https://localhost:8443/svn/project-foobar-import/branches/ -m "Folder moved"

svn delete https://localhost:8443/svn/project-foobar-import/foo/Project-FooBar/ -m "Folder deleted"

@rem Sync with Google Code
svnsync init https://project-foobar.googlecode.com/svn/ https://localhost:8443/svn/project-foobar-import/
svnsync sync https://project-foobar.googlecode.com/svn/

Introducing Graffiti-UserGroups for Graffiti CMS

Alexander Groß — Tue, 06 May 2008 17:22:14 GMT

It's been a while: Sometime last August the SharePoint hosting contract for the .NET User Group Leipzig ran out and since then we basically didn't have an online presence. Our .NET Summercamp 2007 conference and a couple of smaller User Group events took away their share of spare time so I didn't find time to create our new home page. Over the last couple of months I evaluated several Content Management Systems for our to-be-developed homepage and what can I say, I was a bit disappointed. One CMS to remain unnamed showed very buggy behavior when setting up basic navigation elements and DotNetNuke had some scary CSS to override for custom layouts and uses tables all over the place.

Two months ago I came across telligent's Graffiti CMS. Delightful! They really appear to be driven by their "Content Made Simple" concept. Not only do they have a nice Ajax-y administration UI, Graffiti also provides an extremely simple and efficient extensibility model. The NVelocity template engine is also very easy to grasp. (NVelocity is part of my beloved Castle project.)

I started implementing some macros for the User Group events, and soon it became clear that this might be something other User Groups might want to use as well. Thus, the open-source Graffiti-UserGroups project was born.

Basically we wanted to provide a list of recent and archived events with custom metadata and enable attendee registration. Speaking of metadata, this includes:

Start and end dates
- and time, optionally
Speaker
Location
- A default location should be set if no location was entered.
Maximum number of attendees (due to space limitations)
- Again, a default maximum should be set if no value was given.
Registration recipient e-mail address
- A default address should be used if no e-mail address was given. We sometimes host events in cooperation with the local Microsoft Student Partners (MSPs) so the address can change for MSP events.

This enables some neat use cases:

Registration for one or more events using a web form without needing to write an e-mail.
Automatic e-mails to the attendee and the event organizer.
The notion of waiting lists for events that are booked up.
iCalendar item downloads for Outlook that are created based on the metadata above.

All functionality can be implemented using Graffiti's extensibility points, a plug-in in this case. A plug-in can subscribe to certain events in the application, jump in and modify data (see default values above). Another extensibility point which is heavily used in Graffiti-UserGroups is the notion of custom "Chalk" macros compiled into .NET assemblies. For example, there's a set of macros to display and format event data without the need to write complex "standard" Chalk statements.

An extra bonus for the Graffiti-UserGroups newbie is the Demo Site Setup Wizard which configures your Graffiti site, including sample posts and a registration page. (Also see the video below where I demo the initial setup which is finished in minutes.)

To make a long story short(er) I've recorded a screencast that shows you how to set up the demo site quickly on your local machine.

Don't forget to take a look at the new .NET User Group Leipzig homepage to see the macros in action. Also check out the source code on Google Code!

Batch Installing SharePoint Solution Deployment Packages (WSPs)

Alexander Groß — Fri, 11 Apr 2008 19:57:35 GMT

Because I needed to install the 20 free SharePoint Application Templates twice this week and Microsoft does not dare to include a batch installer... The batch below installs all *.wsp files in the current directory and deploys them immediately. Hopefully this saves you some time.

@echo off
for %%f in (*.wsp) do (
    echo File %%f
    "%CommonProgramFiles%\Microsoft Shared\web server extensions\12\BIN\stsadm.exe" -o addsolution -filename "%%f"
    "%CommonProgramFiles%\Microsoft Shared\web server extensions\12\BIN\stsadm.exe" -o deploysolution -name "%%f" -allowgacdeployment -immediate -force
)

"%CommonProgramFiles%\Microsoft Shared\web server extensions\12\BIN\stsadm.exe" -o copyappbincontent
"%CommonProgramFiles%\Microsoft Shared\web server extensions\12\BIN\stsadm.exe" -o execadmsvcjobs
iisreset.exe

Beilagen zum Steak

Alexander Groß — Fri, 11 Apr 2008 19:54:03 GMT

500 g Champignons
100 g Mascarpone
1 Zitrone
Schnittlauch
Salz, Pfeffer
1-2 EL Butter

Die Champignons putzen und in grobe Stücke schneiden. Die Butter in einer beschichteten Pfanne zergehen lassen und die Pilze kurz und kräftig anbraten, sie dürfen nicht zu sehr zusammenschrumpfen und nur wenig Wasser verlieren. Die Mascarpone hinzugeben und schmelzen lassen. Mit Zitronensaft abschmecken, sodass ein leicht säuerliches Aroma entsteht. Salzen, Pfeffern und mit Schnittlauch garnieren.

Ebenfalls gut zu Steak passen Kartoffeln mit Butter und Blauschimmelkäse.

Debugging/Printing Custom NAnt Properties When Building A Project

Alexander Groß — Mon, 10 Mar 2008 20:06:11 GMT

A while ago, after reading Jean-Paul Boodhoo's excellent NAnt starter series, I switched my builds to NAnt (before I had just used VS to build). After a couple of hours of figuring out how to organize the structure of the build script, I was delighted how easy it could be to build whole Visual Studio solutions on the command line. NAnt also makes the development environment a lot easier to manage (and more fun) in regard to different configurations on the developer machine vs. test and production. Several projects come to mind in which I would have loved to use NAnt for a better experience when working in a team of developers.

NAnt allows us to apply different settings (think of a database connection string) for various environments and configurations, for which it relies heavily on the easy to grasp concept of properties. Properties may be defined anywhere within a NAnt project file, but I like to keep them separate in a file called default.properties, which might look like this:

<?xml version="1.0"?>
<project xmlns="http://nant.sf.net/release/0.86-beta1/nant.xsd">
    <property name="db.connectionstring"
              value="Data Source=CRM03; Integrated Security=true" />
</project>

In the contrived example above, there is one property defined, db.connectionstring. A developer might want to use another database name on his machine, so he creates another properties file, local.properties, which is loaded by the build script and overwrites the default value of db.connectionstring.

<?xml version="1.0"?>
<project xmlns="http://nant.sf.net/release/0.86-beta1/nant.xsd">
    <property name="db.connectionstring"
              value="Data Source=CRM_Database; Integrated Security=true" />
</project>

The build script loading both files (in case they exists):

<?xml version="1.0"?>
<project name="Project"
         default="all"
         xmlns="http://nant.sf.net/release/0.86-beta1/nant.xsd">

    <!-- Load default configuration. -->
    <if test="${file::exists('default.properties')}">
        <echo message="Loading default.properties" />
        <include buildfile="default.properties" />
    </if>

    <!-- Load developer-specific configuration. -->
    <if test="${file::exists('local.properties')}">
        <echo message="Loading local.properties" />
        <include buildfile="local.properties" />
    </if>
    ...
</project>

Read more about this concept in part 6 of Jean-Paul's series.

The interesting part is now how to output the properties when you run a build. It's easy to print property values using NAnt's built-in <echo> task:

<?xml version="1.0"?>
<project name="Project"
         default="all"
         xmlns="http://nant.sf.net/release/0.86-beta1/nant.xsd">

    <!-- Load default configuration. -->
    <if test="${file::exists('default.properties')}">
        <echo message="Loading default.properties" />
        <include buildfile="default.properties" />
    </if>

    <!-- Load developer-specific configuration. -->
    <if test="${file::exists('local.properties')}">
        <echo message="Loading local.properties" />
        <include buildfile="local.properties" />
    </if>

    <echo message="Build configuration:" />
    <echo message="db.connectionstring: ${db.connectionstring}" />
    ...
</project>

In a larger project the NAnt properties file might grow pretty quick, depending on how many aspects of the system are dependent on environment specifics or build configurations. If you have 25 properties, it becomes a hassle to write an echo task for each of them. Also, when adding a new property, the developer has to remember to add the corresponding echo task.

The NAnt <script> task comes in handy here, which allows us to iterate through all properties and print them using an echo task we create on the fly. Note that we also get back NAnt's own properties starting with "nant.", which will be excluded from the output.

<?xml version="1.0"?>
<project name="Project"
         default="all"
         xmlns="http://nant.sf.net/release/0.86-beta1/nant.xsd">
 
    <!-- Load default configuration. -->
    <if test="${file::exists('default.properties')}">
        <echo message="Loading default.properties" />
        <include buildfile="default.properties" />
    </if>
 
    <!-- Load developer-specific configuration. -->
    <if test="${file::exists('local.properties')}">
        <echo message="Loading local.properties" />
        <include buildfile="local.properties" />
    </if>
 
    <echo message="Build configuration:" />
    <script language="C#">
        <code>
            <![CDATA[
                public static void ScriptMain(Project project)
                {
                    System.Collections.Generic.SortedDictionary<string, string> sortedByKey = new System.Collections.Generic.SortedDictionary<string, string>();
                    foreach(DictionaryEntry de in project.Properties)
                    {
                        sortedByKey.Add(de.Key.ToString(), de.Value.ToString());
                    } 
 
                    NAnt.Core.Tasks.EchoTask echo = new NAnt.Core.Tasks.EchoTask();
                    echo.Project = project;
                    foreach(System.Collections.Generic.KeyValuePair<string, string> kvp in sortedByKey)
                    {
                        if(kvp.Key.StartsWith("nant."))
                        {
                            continue;
                        }  
                        echo.Message = String.Format("{0}: {1}", kvp.Key, kvp.Value);
                        echo.Execute();
                    }
                }
            ]]>
        </code>
    </script>
    ...
</project>

General Considerations For Securing Windows Servers On The Internet (And Anywhere Else)

Alexander Groß — Fri, 08 Feb 2008 16:04:26 GMT

By now there are a couple of Windows Servers that I actively manage, or, in the case of projects, I touched while moving the project forward. Most of these servers have an Internet connection. Since I've been asked how to make servers more secure and manageable, here are a couple of management rules I applied. Consider it a checklist.

Use a firewall and configure it accordingly.
Enable automatic Windows Updates and upgrade to Microsoft Update to receive updates of other Microsoft products like SQL Server.

Okay, the two above should have been obvious.

Keep the machine clean.
Don't install any unnecessary software and don't leave any temporary files on the server. I've seen certificate requests lingering on drive C: and "test" folder remnants. A clean system might reveal hacker activity early in case they leave unfamiliar files behind.
Leverage the principle of least privilege.
All users and service accounts should only have the minimum rights they need. Configure the file system such that system services can only access the files and folders they are in charge of. Typical example: Use a dedicated service account for SQL Server. (Setting this up on SQL 2005 is even more simple.)
Rename the Administrator account.
Rename the Administrator account and make it match your preferred user naming scheme (i. e. agross). You might apply this to your whole organization if you use Active Directory. This is another hurdle to guess the Administrator account from a list of user accounts and works good with account lockout enabled (see below).
Create a new "Administrator" account
and give it a very strong throw-away password. I typically use two or three concatenated GUIDs that I immediately forget. Disallow this user to change his password, remove all group memberships and disable the account.
Audit the hell out of the machine.
Windows uses the Security event log to record security-related events. Configure auditing using secpol.msc and enable success and failure logging at least for
- Account logon events,
- Logon events and
- Policy change.
The last option is for tracking changes to the policy you just set.
Enable complexity criteria for passwords and account lockout.
To be found in the same MMC snap-in as above. For account lockout I often go with the default values of 5 attempts and 30 minutes of threshold and duration.
Deactivate file sharing/Microsoft Networking on the WAN connection.
Because it's most likely unneeded.
Secure RDP sessions using a certificate.
Torsten has a nice write-up on how to leverage SSL to secure the RDP handshaking/authentication phase to overcome man-in-the-middle and ARP spoofing attacks. His article is available in German only so here's two-sentence recap: On the server's RDP security tab, enable SSL and choose the same certificate you use for HTTPS encryption. On the client side, enable server authentication.

Extra: Allow RDP sessions only from white-listed workstations.
For a server that was hacked a while ago using an ARP spoofing attack (see bullet above) I wrote a Powershell script forces RDP session to originate from a list of known workstations. Each RDP user can have multiple allowed workstations. If a logon attempt occurs from another machine that RDP session is killed immediately.

#
# Alert.ps1
#
# Logon script for users with known RDP client names.
#

# Array of users with known workstations.
$userWorkstations = @{
	"user1" = @("VALIDCOMPUTERNAME1", "VALIDCOMPUTERNAME2")
	"user2" = @("VALIDCOMPUTERNAME3")
	}

# Logoff executable.
$logoffCommand = $Env:SystemRoot + "\system32\logoff.exe"

# Trim the user name.
$currentUser = $Env:UserName.Trim()

# Cancel if a user that's not contained in $userWorkstations logs on.
if ($userWorkstations.Keys -inotcontains $currentUser)
{
	return
}

# Send alert e-mail and log off if the user logs on from an unknown workstation.
if ($userWorkstations[$currentUser] -inotcontains $Env:ClientName.Trim())
{
	$subject = $("Unknown RDP client '{0}' for user '{1}'" -f $Env:ClientName.Trim(), $currentUser)

	$message = New-Object System.Net.Mail.MailMessage
	$message.From = "alerts@example.com"
	$message.To.Add("admin1@example.com")
	$message.To.Add("admin2@example.com")

	$message.IsBodyHtml = $false
	$message.Priority = [System.Net.Mail.MailPriority]::High
	$message.Subject = $subject
	$message.Body = $subject

	$smtp = New-Object System.Net.Mail.SmtpClient
	$smtp.Host = "localhost"
	$smtp.Send($message)

	# Force logoff.
	&$logoffCommand
}

Set the script as a logon script for your users using the Alert.cmd helper script below.

rem Alert.cmd - runs the Alert.ps1 Powershell script.
@powershell.exe -noprofile -command .\Alert.ps1

Enable SQL Server integrated authentication.
I don't see a need for SQL Server Authentication in most scenarios, especially if you're running/hosting .NET applications. However, in some projects I've worked on there seems to be a tendency towards SQL Server Authentication for no special reason.
Configure IIS log detail and directories.
I tend to enable full IIS logs, that is, all information regarding a request should be logged. Also, I like my logs residing in "speaking" folders, so instead of %windir%\system32\LogFiles\W3SVC<Some number> they should be placed in %windir%\system32\LogFiles\IIS <Site name>\W3SVC<Some number>. This makes it easy to find the logs you're interested in.
Use SSH to connect remotely.
There's a little free SSH server out there that should fit most user's needs. Besides a secure shell environment freeSSHd offers SFTP and port tunneling capabilities to tunnel insecure protocols. Authentication works natively against Windows accounts.
Deploy a server monitoring tool.
I like to use the free MRTG tool, of course any other tool allowing you quickly view any uncommon activity to will do.
Use a dedicated management network interface, if possible.
You should configure strict firewall rules for that interface. Allow access only from a known management subnet.

What rules do you apply to make your servers more secure and manageable?

Now Playing [?]: Morcheeba – Dive Deep – Enjoy the ride (feat. Judy Tzuke)

Reconfiguring Team Foundation Server URLs

Alexander Groß — Wed, 06 Feb 2008 19:15:25 GMT

Microsoft's solution to integrated software project management, the Team Foundation Server product, offers a lot of services. Beyond Source Control they have a work item tracking, build services and reporting in stock (I suspect there is even more functionality under the hood). You might be tempted to think that such an "all-in-one" solution can become complex to manage pretty soon. Let me tell you, it does! A couple of months ago I set up a Team Foundation Server (beta 2) for a project some friends of mine do for Microsoft (you will hear of it, I promise).

The server was initially installed as a virtual machine on our pretty decent server connected to the DSL line at home. The installation alone took me a week to complete since there was a bug in some XML file that made Visual Studio 2005 misinterpret the file's contents. (I don't remember exactly the source of the problem.) It was quite a hassle to get my first TFS project created.

The project hosted on that server went well, but it became pretty soon obvious that the team needed more resources in respect to bandwidth and virtual machines for testing the application they build. That's something we could not handle with our 640 kbit/s upload bandwidth and 1,5 GBs of RAM in the server. We moved the TFS virtual machine to another physical machine (more RAM) and hooked it up to the University network (lots of free bandwidth).

After moving the server we found that new projects could not be created due to one misconfigured Team System service URL, i. e. that service could be accessed on the home network (think http://tfs/) but not over the Internet. Specifically it was the URL to the SharePoint Central Administration Web Site, but that doesn't actually matter. I checked TFS' Registration Service to see if the corrected URL has been applied. The Registration Service URL looks like this:

http://<TFS Server>:<Port>/Services/v1.0/Registration.asmx

The WssAdminService has a publicy known URL. Good to go! I tried creating a new project, but received that same error as before.

The error message above is a bit misleading because the Team Foundation Client did not try to connect to tfs.therightstuff.de, but rather to the (old) tfs server, as Fiddler revealed.

Looking through the other HTTP requests originating from Visual Studio's Team Foundation Client I found that the Registration Service has never been queried to get the updated service URLs. On Buck Hodges' blog I found a hint:

When a client app, such as tf.exe, VS, or your own custom application, needs to use version control, the TF client code must request the service definition from registration service on the server. To avoid constantly requesting service registration information that rarely changes, the client-side registration code maintains a cache and only makes the server call when the cache is out of date.

Whatever it means that the client re-requests that piece of information when it's out of date. On my machine the Team Foundation cache mentioned above is located at the folder

C:\Users\<User name>\AppData\Local\Microsoft\Team Foundation\2.0\Cache\

I wiped the cache folder and, just to make sure, I also deleted the TFS server registration in Visual Studio.

After re-adding the TFS server in Visual Studio I can now create new Team Foundation projects. Wow!

Now Playing [?]: The Cinematic Orchestra – Horizon – Oregon

The Case Of The Giant SQL Server Log Files

Alexander Groß — Wed, 30 Jan 2008 18:10:32 GMT

The day before yesterday I had to look into a SQL Server 2005 (Service Pack 2) instance where the daily backups of a certain database amounted to several Gigabytes over the last 14 days. The database in question is only about 10 MB in size and the recovery model is set to "Simple" so that should not be the case. The problem was a giant log file, around 6 GB in size by the time I started the remote session.

First I tried shrinking the database and the logs via the Context Menu, Tasks, Shrink Database options, but shrinking the log file failed miserably: it would not decrease below a magic threshold of 5,5 GB. Shrinking even should not free that much disk space because SQL Server shrinks the logs automatically after a transaction is committed when the recovery model is set to "Simple".

After a while of trial and error I realized that there must be some open transaction that has not been committed or otherwise been marked as done. But how to finally get rid of it?

First I tried to change the recover model to "Full" and "Bulk-logged", backing up the database and the logs separately.

BACKUP DATABASE database TO DISK='C:\Temp\file_data.bak' WITH NO_LOG
BACKUP LOG database TO DISK='C:\Temp\file_log.bak'

Processed 1000 pages for database 'database', file 'database_Data' on file 2.
BACKUP DATABASE...FILE= successfully processed 1000 pages in 0.434 seconds (18.875 MB/sec).

Processed 807822 pages for database 'database', file 'database_Log' on file 3.
The log was not truncated because records at the beginning of the log are pending replication. Ensure the Log Reader Agent is running or use sp_repldone to mark transactions as distributed.
BACKUP LOG successfully processed 807822 pages in 15.077 seconds (48.119 MB/sec).

As you can see from the messages above the shrink operation could not shrink the whole log file. The hint to use sp_repldone is a bit misguiding because the database isn't replicated. In fact, the replication components aren't even installed on the server. As expected, executing sp_repldone fails:

EXEC sp_repldone @xactid = NULL, @xact_segno = NULL, @numtrans = 0, @time = 0, @reset = 1

Msg 18757, Level 16, State 1, Procedure sp_repldone, Line 1
Unable to execute procedure. The database is not published. Execute the procedure in a database that is published for replication.

I digged the SQL Server Books Online for more information. First of all there's a command to find out about open transactions: DBCC OPENTRAN. As you can see there's at least one transaction that hasn't been replicated.

DBCC OPENTRAN

...
Replicated Transaction Information:
   Oldest distributed LSN     : (0:0:0)
   Oldest non-distributed LSN : (3822:331:1)
   DBCC execution completed. If DBCC printed error messages, contact your system administrator.

At least, it was the hint that finally solved the issue: There's a transaction that SQL Server thinks should be distributed to a replicated server, although there is none configured.

Fortunately, there's a stored procedure that can be used to disable replication, even if it wasn't enabled in the first place. I suspect sp_removedbreplication cleans up some bogus settings, at least it was able to remove the transaction that kept the log file steady at 5,5 GB.

Two hours later: Problem solved!

Now Playing [?]: Ocker – Public Transport – Last night the secret service saved my life

Siemens Gigaset QuickSync on Vista x64

Alexander Groß — Sat, 19 Jan 2008 15:12:43 GMT

I recently purchased the Siemens Gigaset SL 370 phone for home telecommunications. The SL 370 is Siemens' premier DECT phone with a form factor comparable to mobile phones. It has plenty of advanced features, the most appealing one being Bluetooth support for headsets and, more importantly, syncing abilities with Outlook contacts. That is, you can sync your Windows Vista Contacts folder or Outlook contacts wirelessly over a Bluetooth connection.

On the SL 370 product support site there's a download option for the Gigaset QuickSync software needed for synchronizing the contact stores on your computer and the handset device. The software version I'm using is the current version 2.0 which needs the .NET Framework 2.0 to run (which is a good thing, see below).

The SL 370 is a great piece of hardware, good sound quality, very light, well thought out and with outstanding battery life.

However, there are some issues with the QuickSync software with Outlook 2007:

Gigaset QuickSync refuses to run on x64 versions of Windows Vista

After launching QuickSync on Vista x64, Windows instantly shows the generic "Program stopped working" dialog.

After clicking the "Debug" button Visual Studio starts up revealing that an assembly of the Gigaset QuickSync package refused to load. When the application's main executable (GigasetQuickSync.exe) tries loading PCABManager.dll a BadImageFormatException is thrown.

As one can glimpse from the screenshot above the PCABManager.dll assembly is not strong named (PublicKeyToken=null), so I could leverage some of the .NET Framework SDK tools to make QuickSync behave on Vista x64.

Open up a Visual Studio Command Prompt and run corflags.exe on the GigasetQuickSync.exe and PCABManager.dll assemblies.

corflags /32bit+ GigasetQuickSync.exe
corflags /32bit+ PCABManager.dll

The 32-bitness flags should be set afterwards

>corflags GigasetQuickSync.exe
Microsoft (R) .NET Framework CorFlags Conversion Tool.  Version  3.5.21022.8
Copyright (c) Microsoft Corporation.  All rights reserved.

Version   : v2.0.50727
CLR Header: 2.5
PE        : PE32
CorFlags  : 1
ILONLY    : 1
32BIT     : 1
Signed    : 0

This resolves the load errors on Vista x64 as we now force the 32-bit .NET Framework runtime to load. More technical details can be found on Scott Hanselman's blog (about 50% into the post).

Deleted Outlook contacts sync back

Because the phone has only a limited number of contacts (250) there's a filter dialog that can be used to tell the Gigaset QuickSync software which contacts should not be transmitted to the handset. Note that QuickSync will only load contacts that have a telephone number, so the contact count might differ from what Outlook reports.

Nice, but today flash memory is cheaper than ever before. Why did the SL 370 product designers choose to have only 250 contacts on a 120 € phone?

One (unresolved) problem I experience with the "syncing" ability is that if you delete an Outlook contact and re-sync the previously deleted contact will be recreated in Outlook. I suppose this is a known bug. One work-around is to delete all contacts on the phone before syncing.

Conclusion

The SL 370 is a great phone: I adore its flyweight, the clean UI, the great battery power and the rich set of options like turning down the ringtone volume at nighttime. The weaknesses on the Windows software side should be fixed in the next release of the QuickSync.

Now Playing [?]: Sie – Ruban D'Alpha – Ciru catena

Neulich im Späti

Alexander Groß — Fri, 04 Jan 2008 17:23:12 GMT

Vielleicht hat's auch deswegen nicht mit dem Geschäft geklappt?

Rezept: Hähnchenschenkel mit getrockneten Feigen

Alexander Groß — Fri, 04 Jan 2008 17:07:31 GMT

4 Hähnchenschenkel
2 rote Zwiebeln
3 Knoblauchzehen
3 getrocknete Feigen
1 süßer Apfel
etwas Apfelsaft
Olivenöl
1 TL Honig
Salz, Pfeffer

Zwiebeln und Knoblauch schälen und in Spalten schneiden. Den Apfel ebenfalls in Spalten zerlegen. Die getrockneten Feigen würfeln. Einen Bräter mit Olivenöl bestreichen; Zwiebeln, Knoblauch und Feigen gleichmäßig darin verteilen. Die Hähnchenschenkel salzen, pfeffern und obenauf legen, Zwischenräume mit Apfelstückchen auffüllen. 50 ml Apfelsaft aufgießen.

Den Bräter mit geschlossenem Deckel 45 min. bei mittlerer Hitze in den Ofen stellen. Anschließend den Deckel abnehmen und die Hähnchenschenkel mit Honig besteichen. Bei Oberhitze überkrusten.

Dazu passt Baguette oder Couscous mit Rosinen (hierfür die Rosinen vorher in etwas Apfelsaft aufkochen und weichen lassen).

New DasBlog Macros for On-Page Navigation and Post Modification Date

Alexander Groß — Sun, 30 Dec 2007 15:08:54 GMT

Per Torsten's request I created a couple of new macros for DasBlog.

On-Page Navigation

Torsten wanted to enable on-page navigation to the next and previous post, comparable to the mail navigation introduced in Outlook 2007:

The OnPageNextLink and OnPagePreviousLink macros display a link to the next and previous post on the current page in list view. Please note that these macros don't create link across pages. For example, the last post on the page doesn't have a previous link, even though there might me older posts.

Because I use URL rewriting to get rid of /default.aspx in my home page URL an issue with the browser reloading the whole page came up, making is necessary to create a couple of overloads:

OnPageNextLink(navigationText)OnPagePreviousLink(navigationText)
Renders a link to the next/previous post on the current page. The CSS class for the anchor tag is next and previous, respectively. The navigationText parameter takes a string containing different locale versions of the text to be displayed as used in the LocalString macro.
The first post on the page does not have a "next" link, whereas the last post on the page does not have a "previous" link.
OnPageNextLink(navigationText, removeUrlFragmentRegex)OnPagePreviousLink(navigationText, removeUrlFragmentRegex)
Same as above. The regular expression specified by the removeUrlFragments parameter will be used to remove parts from the URL.
If you use URL rewriting for /default.aspx, the regular expression is default\.aspx$.
OnPageNextLink(navigationText, cssClass, removeUrlFragmentRegex)OnPagePreviousLink(navigationText, cssClass, removeUrlFragmentRegex)
Same as above, but you are able to set the CSS class explicitly.

Example

In your itemTemplate.blogtemplate, embed the macro markup for the on-page navigation. Note that in this example uses a regular expression to remove a tailing "default.aspx" from URLs:

<% OnPageNextLink("Next|DE:Weiter", "default\.aspx$") %>
<% OnPagePreviousLink("Previous|DE:Zurück", "default\.aspx$") %>

This will render the following HTML for /default.aspx which can be styled using CSS:

<a class="next" href="http://www.therightstuff.de/#<some-guid>">Next</a>
<a class="previous" href="http://www.therightstuff.de/#<some-guid>">Previous</a>

The HTML for URLs other than /default.aspx:

<a class="next" href="http://www.therightstuff.de/default,page,1.aspx#<some-guid>">Next</a>
<a class="previous" href="http://www.therightstuff.de/default,page,1.aspx#<some-guid>">Previous</a>

Post Modification Date

Another requirement Torsten had is to be able to display the modification date of a post. For unedited posts this date is equal to the creation date, which we use to decide whether to display the modification date or not. There are a couple of overloads:

Modified
Displays the modification date if the post has been modified. (Comparable to the When macro.)
FormattedModified(format)
Displays the formatted modification date if the post has been modified and appends the timezone the blog is hosted in. (Comparable to the FormattedWhen macro.)
FormattedModifiedBare(format)
Displays the formatted modification date if the post has been modified and does not append the timezone the blog is hosted in. (Comparable to the FormattedWhenBare macro.)
IfModified(expression)
Displays localized text if the post has been modified. The expression parameter takes a string containing different locale versions of the text as used in the LocalString macro.

Example

In your itemTemplate.blogtemplate, embed the macro markup for the post creation date and the modification date:

<% LocalString("Posted in|DE:Veröffentlicht unter") %> <% categoryLinks %>
<% LocalString("at|DE:am") %> <% FormattedWhen("f") %>
<% IfModified(" and changed at |DE: und verändert am ") %><% FormattedModified("f") %>

This will render the following HTML for an edited post:

Now Playing [?]: Ulrich Schnauss – Goodbye – Stars

Prof. Harald Lesch: Neues Format, neue Folgen

Alexander Groß — Sun, 23 Dec 2007 14:04:33 GMT

Anfang dieses Jahres wurde einer der wenigen brauchbaren Fernsehangebote aus dem Programm gestrichen: Der Bayerische Rundfunk hat Alpha Centauri abgesetzt.

Ein mir bislang unbekannter Spartensender namens SciFi hat Alpha Centauri nun neu aufgelegt: Prof. Lesch wandelt als "Sci_xpert" ganz in weiß in einem ebenso weißen Studio und referiert in gewohnt einleuchtender Art und Weise über die Zukunft und die Geheimnisse des Weltalls. Jede Woche gibt es eine neue Folge zum Download, per YouTube oder als RSS Feed.

Die Hintergrundmusik stammt übrigens von diesem meisterhaften Album:

Now Playing [?]: Kruder & Dorfmeister – The K&D Sessions – Sofa Surfers – Sofa rockers (Richard Dorfmeister Remix)