Mike Nichols - Son Of Nun Technology

Help Wanted

Michael Nichols — Tue, 25 Oct 2011 19:45:00 GMT

We have need for a .net dev familiar with the stack belowto help us wrap up a fairly lite project.

This is a CQRS project but even if you haven't worked on a CQRS project but are somewhat familiar with its tenets you should pick it up quickly.

Mostly the work will be done simply formatting the reads on the web client and some basic UX stuff.

Stack:

Castle Windsor
NHibernate/FluentNH
ASP.NET MVC
joliver EventStore (shouldn't need to touch this though).

If you have some hours open and are available immediately please
contact me directly to discuss.

Thanks!

Backbone Events and Aggregator Update

Michael Nichols — Thu, 20 Oct 2011 22:02:00 GMT

Dispatcher / EventAggregator update

Earlier I posted an implementation of EventAggregator for Backbone.js. Please read that first.

Tracking down bugs in an EDA setup can be tough. This one had me going crazy.

I had forgotten to take into consideration Backbone.js's behavior regarding events being triggered inside a Model which is:

If a model is a member of a collection, all events triggered in that model will also be triggered on the collection.

This is handy - and dangerous. To keep this behavior and prevent my Event Aggregator implementation from double-firing the same event, a small fix needed to be inserted. Note the check below for isEligibleForDispatcher:

BackboneExt {...

    dispatcher : _.extend({}, Backbone.Events, { cid : 'dispatcher'}),
    wrappedEvents : function (localEvents) {
        var local = localEvents || _.extend({}, Backbone.Events);
        var isEligibleForDispatcher = function (source) {
            return !((source instanceof Backbone.Model) && (source.collection instanceof Backbone.Collection));

        }
        //note that 'this' is the Backbone implementation
        return {
            dispatcher : BackboneExt.dispatcher,
            trigger : function () {
                BackboneExt.trigger('wrappedEvents:triggered', this);

                // this._callbacks is an internal collection 
                // currently backbone could 
                if (this._callbacks) {
                    local.trigger.apply(this, arguments);
                }
                if (isEligibleForDispatcher(this)) {
                    //we must call dispatchers trigger with the dispatcher as 'this''
                    //otherwise, the wrong collection will be queried for _.callbacks                        
                    BackboneExt.dispatcher.trigger.apply(BackboneExt.dispatcher, arguments);
                    BackboneExt.trigger('dispatcher:triggered', this);
                }    
                return this;
            }

        };

    },
    extendBackbone : function () {
        var self = this;
        if (self.isExtended) {
            return;
        }
        _.each(backbonePrototypes, function (proto) {
            _.extend(proto,  self.wrappedEvents());
        });
    }

Backbone events : being careful

In general, I avoid triggering events from my initialize methods on my models. I have found that when I do so, the event is not fired on the collection. So if there are other objects that bind to my dispatcher they will not receive these events if they are fired inside a Model.initialize method.

Backbone Event Aggregator extended

Michael Nichols — Mon, 15 Aug 2011 03:21:00 GMT

UPDATE : Please use the code found in my follow-up.

Derick Bailey wrote a great post decoupling Backbone Views from one another through the use of an Event Aggregator. I wanted to use this without passing in the dispatcher into all these Views, Models, etc. To accomplish this I came up with the following:

//namespace our extensions

var BackboneExt = BackboneExt || function() {
    var backbonePrototypes = [
        Backbone.Collection.prototype, 
        Backbone.Model.prototype, 
        Backbone.View.prototype,
        Backbone.Router.prototype
    ];

    var extensions = {

        dispatcher : _.extend({}, Backbone.Events,{cid : 'dispatcher'}),
        wrappedEvents : function(localEvents) {
            var local = localEvents || _.extend({},Backbone.Events);
            //note that 'this' is the Backbone implementation
            return {            
                dispatcher : BackboneExt.dispatcher,            
                trigger : function() {                                      
                    var args = _.toArray(arguments);                
                    // this._callbacks is an internal collection 
                    // currently backbone could 
                    if( this._callbacks ) {                             
                        local.trigger.apply(this,args);
                    }               
                    BackboneExt.dispatcher.trigger.apply(BackboneExt.dispatcher,args);
                    return this;            
                }

            };

        },
        extendBackbone : function() {
            var self = this;
            if( self.isExtended ) {
                return;
            }
            _.each(backbonePrototypes,function(proto) {
                _.extend(proto, self.autoBinder, self.wrappedEvents());
            });
        }
    };
    return extensions;
}();

BackboneExt.extendBackbone();

Note that dispatcher is now exposed in any of the Backbone components. We just overwrite the default Backbone.Events.trigger with our own that composes the local trigger with the global (dispatcher) trigger.

`trigger`

This keeps my Backbone components blissfully ignorant of its subscriber(s):

// some simple jquery notification component
BackboneExt.dispatcher.bind('mynamespaced:event', function(args) {
    $('#messages').append(args.message);
});

// some Backbone.Model
var model = new SomeModel({
    // ...
    someMethod : function() {
        this.trigger('mynamespaced:event',{ message : 'something happened' });
    }
});

`bind`

This can work the other way, too, but the Backbone components need to explicitly bind to the exposed dispatcher:

//inside Backbone.Model initializer
var model = new SomeModel( {
    initialize : function() {
        dispatcher.bind('someglobalevent:happened', this.someMethod);
    }
    someMethod : function() { ... }
});

BackboneExt.dispatcher.trigger('someglobalevent:happened', 'something happened'); //calls 'someMethod' in model

Running vmdk (vmware) images on Virtual Box

Michael Nichols — Tue, 26 Jul 2011 05:58:00 GMT

I had one final vmdk image I use for Windows dev that I wanted to use in VirtualBox instead of VMWare.

VirtualBox makes this dead simple but a few things to look out for, since you might get a BSOD that is hard to figure out:

1. Uninstall VMWare tools

2. Mount your image as an IDE, not SATA (the default when using the VirtualBox wizard)

3. Check your root .vmdk file and be sure your disk names don't have extraneous '.' suffices. I discussed this here.

Once I did these I was able to get VirtualBox running my image just fine.

Hope this helps

mike

heroku on linux

Michael Nichols — Wed, 13 Jul 2011 12:54:00 GMT

I ran into a little snag setting up my heroku on my Ubuntu Linux 10 box when I ran

heroku create --stack cedar

What I got in return was

no such file to load -- readline (LoadError).

To resolve this I

apt-get install libncurses5-dev
cd to ruby source; ie ~/.rvm/src/ruby-1.9.2-p136
cd ext readline
ruby extconf.rb
make
make install

voila!

Vim handy : pathogen

Michael Nichols — Thu, 05 May 2011 21:35:00 GMT

I have been trying to be disciplined in using vim for any editor needs outside of my c# development. One thing I have been happy to find early on has been a good way to manage the various plugins I will no doubt use along the way.

It's called 'pathogen' and I found a good way to get started with it here.

Vote For An Up And Comer!

Michael Nichols — Wed, 20 Apr 2011 23:12:00 GMT

A buddy of mine has a very talented son who has entered a German-speaking contest. The video he produced is amazing for such a young fella. If he wins he goes to Germany!

If you have a few moments , why not go and support him? You'll get a kick out of the video even if you don't speak a word of German.

http://cms.goethe.de/ins/us/saf/prj/sig/soc/cot/cli/en7477337.htm

Enjoy!

mike

ditto : with regard to AutoMapper

Michael Nichols — Sun, 10 Apr 2011 23:08:00 GMT

A comparison of ditto to AutoMapper was suggested so I will try to be more specific for some problems ditto has solved for me. Hopefully this help you decide if it is the right tool for your project.

hat tip

Before I 'compare' AutoMapper, let me clearly state that I am not criticizing anyone's work. I suspect AutoMapper has been a big helper to many projects and the community surrounding it seems pretty helpful. It just didn't fit my needs. I tried to use AutoMapper correctly so if I state something in error here please let me know.

I'd also like to highlight that ditto's best friend is Fasterflect. Alot of the reflection magic is handled by this excellent library.

ditto doesn't

First, let me point out a few limitations that currently exist in ditto when compared to AutoMapper.

Dictionaries are not supported ( I believe they are in AutoMapper ). I don't really need this, but it would just be an implementation of IBinder registered on your container.
It is slower than AutoMapper. The benchmarking project I have in my project shows about a -2 sec difference in mapping 10,000 messages. To be honest I haven't spent a ton of time optimizing ditto. It's fast enough for me right now though.
UPDATE : I just pushed a small change that makes my benchmarks 1 second faster than AutoMapper now...My benchmarking tests are simple, so objections are welcome!
Flattening / Unflattening assumptions. This could probably be easily extended into ditto but I actually haven't a need for it since the objects I am focused on are not behavioral.
Conditional mapping . Actually, this is supported but not in an explicit method call.
I am sure there are others. Please comment and I will update this limitations list.

ditto gots-ta-have

The primary attraction of AutoMapper for me was the little call to .AssertConfigurationIsValid();. I knew if I was going to create a similar tool it had to provide this kind of validation.
Provide a fluenty interface but don't tie my hands with generic parameters when a simple Type will do.
No requirement to specify the superfluous generic parameter for the source object when calling .Map().

ditto intent

My focus for ditto is lightweight objects; that is, Data Transfer Objects that are commonly used at application boundaries. That's not to say things like nested objects or collections are not supported (they are).

ditto does

Okay, with that out of the way let's see what ditto DOES do. The hassle in any tool that meets this problem will be found in the configuration bits. Like you'd expect, ditto assumes property names are the same between objects so gives you some help with setting up the mappings based on property name. That's the easy stuff. ditto is greedy so just does this automatically.

The real work comes from exceptions to the rule. Rather than treating the association between two objects as the subject for mapping, I decided to simply treat the destination types as subject and provide a facility for binding together all mappings together to create a validatable, executable whole. This is what I mean on the project when I state the initial goal of ditto was to aggregate data from multiple sources. This gives me the coding/typing freedom from having to specify every property for every source, but also gives me the freakin' cool ability to confirm that all my destination object properties have some mapping configured.

Let's illustrate a lightweight example for what I mean by that. I have a service that receives messages (events) that each contribute bits to a single view model. Each view model has a Denormalizer class that implements an IDenormalize:

public class ProjectViewModelDenormalizer : Denormalize<ProjectViewModel>, 
    IDenormalize<ProjectCreatedEvent>,
    IDenormalize<ProjectSamplesAddedEvent>,
    IDenormalize<ProjectMixCodeDefinedEvent>

    /* implementations of these interfaces */
}

public class ProjectViewModel {
    public Guid ProjectId {get;set;}
    public string Name {get;set;}       
    public List<Guid> SampleIds {get;set;}      
    public string MixCode {get;set;}
    /* about 20 more properties, each coming from 10 different events */
}

public class ProjectCreatedEvent {
    public Guid Id {get;set;}
    public string Name {get;set;}
}

public class ProjectSamplesAddedEvent {
    public List<Guid> SampleIds {get;set;} 
}

public class ProjectMixCodeDefinedEvent {
    public string MixCode {get;set;}
}

/* 10 more events contributing to this view model*/

In order to achieve this in the current drop of AutoMapper and get validation checking I would have to map each property on Project with an .Ignore() call to the properties that each event does not cover. This is due to the AutoMapper signature that requires a <TSource,TDestination> mapping. In order to avoid validation assertion failures, I'd have to zip up this configuration into a custom converter just for the ProjectViewModel but then I lose validation checking which was the strongest feature in AutoMapper for me. Now, this is still workable, but since I have hundreds of these ViewModels it just became too much .Ignore() ing for me. Without a Custom Converter, mapping AutoMapper would look something like this for just these :

public class ProjectViewModelProfile : Profile
{
    protected override void Configure() {
        CreateMap<ProjectCreatedEvent,ProjectViewModel>()
            .ForMember(m => m.SampleIds, opt => opt.Ignore() )
            .ForMember(m => m.ProjectId, opt => opt.MapFrom(its => its.Id) )
            .ForMember(m => m.MixCode, opt => opt.Ignore() );

        CreateMap<ProjectSamplesAddedEvent, ProjectViewModel>()
            .ForMember(m => m.Name, opt => opt.Ignore() )
            .ForMember(m => m.ProjectId, opt => opt.Ignore() )
            .ForMember(m => m.MixCode, opt => opt.Ignore() );

        CreateMap<ProjectMixCodeDefinedEvent, ProjectViewModel>()
            .ForMember(m => m.ProjectId, opt => opt.Ignore() )
            .ForMember(m => m.Name, opt => opt.Ignore() )
            .ForMember(m => m.SampleIds, opt => opt.Ignore() );

        /* 10 more blocks like these repeating .Ignore() */
    }
}

View Models are always changing out so adding properties or tweaking them slightly suddenly becomes very cumbersome due to the repetition of their definitions for each event type.

ditto takes a different approach and executes validation on its mappings after everything has been configured and bound up. It treats the 'Destination' object as the one you are interested in and hollers if the sum of all your sources don't affect one of its properties in some way. So the above model config would be written like this in ditto:

public class ProjectViewModelConfig : AbstractMappingConfiguration {
    public override void Configure() [
        //Cfg is injected by your container...see the docs
        Cfg.Map<ProjectViewModel>().From(typeof(ProjectCreatedEvent),typeof(ProjectSamplesAddedEvent),typeof(ProjectMixCodeDefinedEvent),/*more events?*/)
            .Redirecting<ProjectCreatedEvent>(from => from.Id, to => to.ProjectId );
    }       
}

I typically simplify this with a wee extension method for discovering the source types.

Concepts

ditto basically applies three concepts to execute mapping:

IPropertyCriterion : This is the selector for the destination property to match on a object; ie Naming Convention matching
IResolveValue : This is the behavior of the resolution, given the source and destination (similar to what you see in AutoMapper).
IConvertValue : This is the convention for certain types; ie, DateTime UTC standards

Manually configured mappings take precedence of global conventions. So this means if you apply a convention to ignore all properties with names starting with "System":

Conventions.AddResolver(new PrefixPropertyCriterion("System"),new IgnoreResolver());

But you find later you have a model you do want to participate in mapping execution. You can do this:

Cfg.Map<MyViewModel>().From<MyEventWithSystemDetails>().Redirecting<MyEventWithSystemDetails>( from => from.SystemOS, to => to.OperatingSystem );

This will use your special mapping in this one instance.

More info on setting up global conventions is at the project site README.

Container

Since ditto relies heavily on IoC container to do its thing, it is dead simple to provide your own resolver implementations,organize your mapping files, or override its behavior it a pretty granular level. This means it'd be easy to provide custom ways for creating destination objects, etc.

Execution API

There isn't a need to specify the source object in generic parameters to map your object. Just tell ditto what destination type to map to and your done. Specifying the source type when I am already passing in the source object was more a pet peeve and made my code noisier than I prefer. Probably this could be relieved with a utility extension method AutoMapper though.

var viewModel = ditto.Map<MyViewModel>(message);

This is getting pretty long now. I hope this sheds some light on ditto's purpose for being. If you have more questions either on the API or whether it'd be a good fit for you feel free to comment below or email me.

Enter ditto

Michael Nichols — Thu, 07 Apr 2011 22:01:00 GMT

I just spun off a little framework that performs Object-Object mapping. I was reluctant to throw another tool like this out there since others already exist, but I had difficulty bending existing solutions to my will without reflection tricks or lots of typing.

The main motivation for this mapping implementation was the pattern found in CQRS solutions where a single denormalizer is responsible for updating a view model from multiple events. Also, I wanted to leverage my IoC container for conventions while mapping my Form model in MVC controller code.

If you have any comments or suggestions, I'd love to hear them!

The project is hosted on github at http://github.com/mnichols/ditto. Here are the docs from the project site.

ditto {''} - a small framework for mapping objects to objects in .NET.

Why?

There are good mapping tools out there already, but ditto was conceived to address a specific need for aggregating multiple source objects into a single instance. This is common for event handlers which all contribute their data to a single view model (ie, an event Denormalizer). From this simple model, it became real easy to extend its usage in other scenarios like mapping from a Form model in a web app to Commands in MVC controller code. Also, because it wires everything up using a IoC container, it is dead simple write resolvers, converters, or replace its behavior just by registering your implementations on your container.

Goals (in no particular order):

Convention-based assumptions to minimize configuration as much as possible
Aggregation of source objects into single destination
Deep validation checking
Garrulous
Fluent configuration without typedsturbating generic parameters
Fast enough
IoC, container-based

Limitations

Only properties are evaluated by convention right now
Flattening/Unflattening isn't a concern for me, but it'd be easy to create components to do this without changing Ditto

Assumptions

ditto assumes the objects you are mapping have the same property names. This simple configuration assumes the two objects have the same names:

cfg.Map<MyViewModel>().From<MyEvent>();

Containers

ditto leans heavily on an IoC container to do its work. This lets us easily register resolvers and other bits for easy configuration. Castle Windsor integration is the only container integration provided right now, but ditto doesn't really care how services are getting resolved. If you decide to use the Castle Windsor integration you can just add the provided Facility (DittoFacility). Here's the code installing all mapping services for my view model denormalization daemon:

container.AddFacility("mapping.facility", new DittoFacility());
container.RegisterAllConfigurationsIn(new[] { GetType().Assembly });
container.RegisterAllGlobalConventionsIn(new[]{GetType().Assembly});
container.Register(AllTypes.FromThisAssembly()
                       .BasedOn<IResolveValue>()
                       .WithService.AllInterfaces()
                       .Configure(c => c.LifeStyle.Transient));

Logging

ditto likes to talk alot for Debug builds, so be sure you use a Release build (the default if you use the provided psake script). log4net is the only logging implementation provider right now (baked into Castle Windsor Integration), but it'd be easy to swap that out since ditto doesn't care who is listening.

Configuration

To let ditto know what objects you need to map and their respective sources for data, you need to get the singleton implementation of IContainerDestinationConfiguration. The AbstractMappingConfiguration base class can be inherited from to save a few keystrokes. This assumes you can let your hair down about required services being provided without constructor injection.

public class MyViewModelConfiguration : AbstractMappingConfiguration 
{
    public override void Configure()
    {
        //'Cfg' is injected by your container
        Cfg.Map<MyViewModel>().From<MyEvent>();
    }
}

Conventions

Conventions may be applied globally. Conventions may impact your destination objects in one of two ways:

The resolution of a value based on the context or metadata of associated objects
The conversion of a value for across-the-board metamorphosis; ie, conversion of all DateTime's into UTC

Global conventions are applied to every mapping ditto knows about. To configure Global conventions, you need to add them to IContainGlobalConventions. For this, you may inherit from AbstractGlobalConventionConfiguration:

public class WebAppGlobalMappingConventions : AbstractGlobalConventionConfiguration
{
    private readonly MyCustomResolver myCustomResolver;

    public WebAppGlobalMappingConventions(MyCustomResolver myCustomResolver)
    {
        this.myCustomResolver = myCustomResolver;
    }

    public override void Configure()
    {
        Conventions.AddConverter(new EntityIdentifierConverter()); 
        Conventions.AddConverter(new DateTimeUtcConverter());
        Conventions.AddResolver(new PropertyNameCriterion("ConversationId"),new IgnoreResolver());
        Conventions.AddResolver(new PropertyNameCriterion("Id"),myCustomResolver);
    }
}

Validation

ditto is uptight, so if there are properties on destination objects that are not mapped after everything is bound together, it can let you know. This is done by default if you are using the provided WindsorMappingInitializer. This will throw an exception if there are any properties for which ditto has not been configured, either via global conventions or local mappings.

Intialization

ditto can be initialized in your bootstrapping code by simply getting your instance of IInitializeDitto and calling its Initialize method. Again, there is a WindsorMappingInitializer that demonstrates the things that ditto needs to do for starting up. These are done, in order:

Configure all global conventions
Configure all destination objects from their sources
Bind all these configurations together
Cache configuration metadata (optional, but madness to do without)
Validate/Assert all configuration

Mapping

Once you have initialized ditto you may now just grab your instance of IMap and call it by either having ditto create the destination object for you, or passing in your own instance:

var myViewModel = mapper.Map<MyViewModel>(mySourceEvent); // => this creates an instance of MyViewModel and maps from your instance of the source
mapper.Map(mySourceEvent,myViewModel); // => this simply maps from the source to your own instance of MyViewModel

Please note that ditto currently assumes a default constructor for its own activation of objects. This would be dead simple to improve upon though since it is container-driven. Just replace IActivator and provide your own strategy(s).

Acknowledgements

Fasterflect - ditto developer is lazy so relies on for reflection optimization stuff. It's a great little tool for the toolbox.
Castle Windsor - Makes it easy to keep concerns split up.

Ubuntu 10.10 (Maverick) VMWare Solution

Michael Nichols — Tue, 29 Mar 2011 20:48:00 GMT

I recently committed to using Ubuntu for everything, so I thought I could just run my current development vm's (vmdk files) from my external hard drive as if nothing had really changed.
Problem:
I kept getting a 'File not found' error when I would try to run my virtual machine.
At first, I assumed I had some kind of write permissions missing, or perhaps some NTFS compatibility problem. Since I am pretty new to Linux I first made sure my external HDD was mounted correctly. When I confirmed that, I peeked in the .vmdk file that is referenced by the .vmx file used to configure the machine.

Here’s what I saw...this is a 40gb hard drive split into 2gb files:

# Extent description
RW 4193792 FLAT "win2k8Dev1.vmdk-f001." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f002." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f003." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f004." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f005." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f006." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f007." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f008." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f009." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f010." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f011." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f012." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f013." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f014." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f015." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f016." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f017." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f018." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f019." 0
RW 4193792 FLAT "win2k8Dev1.vmdk-f020." 0
RW 10240 FLAT "win2k8Dev1.vmdk-f021." 0

Do you see the “.” at the end of the file name? The file names are not suffixed with a period as the file names in the listing would seem to indicate. After removing the character from the file names I was able to run my machine again.

I am not quite sure what the intent is here for this naming convention...I presume this is some kind delimiter in VMWare’s app. I have gone back and forth between Linux and Windows hosts since removing the offending character and it seems to work swimmingly.

I hope this helps someone.

Notes From A Project Applying Domain-Driven Design, Event Sourcing and CQRS : Part 3 – Messaging In Web Applications

Michael Nichols — Thu, 24 Jun 2010 23:00:08 GMT

Today I am not strictly mouthing off strictly about the three things in the title, but more about the side-effects of their joy in a web application.

Two things have made me feel dirty while implementing a messaging solution in a web application while adhering strictly to Command-Query Separation.

Why do I have a single controller SENDING messages (commands), and READING (reporting) data?
What patterns exist beyond just a correlation id for notifying the user when their commands’ processing are completed?

The first one is the one on my mind today as I am testing the bits that send the messages to my Win service hosting my domain. The second one I will deal with in the next post.

My controllers look pretty typical:

public class ProjectController : Controller
{
    IExecuteCommands bus;
    public void ProjectController(IExecuteCommands bus)
    {
        this.bus=bus;
    }
    public ActionResult New()
    {
        return View(new NewProjectViewModel() };
    }
    public ActionResult Create(CreateProjectCommand project)
    {
        bus.Send(project);
        return this.RedirectToAction<MessagingController>(c=>c.Wait(this.ConversationId));
    }
}

My controllers are either reading or writing…why do I have the same controller doing both? The semi-optional service dependencies are a smell that I am putting too many responsibilities here. I already adhere to POST-REDIRECT-GET convention, so it seems unnecessary.

Why not split this into :

ProjectController = Only GET requests
ProjectCommandController = Only POST requests

Since the majority of actions are reads and we want take of advantage of conventions in frameworks like MVC for urls, we can just pull our state-changing actions into a separate controller and append the name with ‘Command’.

Commands abiding by some kind of naming convention, perhaps ‘Execute’ prefix, would simply be routed to the [ControllerName] + ‘Command’ Controller.

This would make testing simpler since I don’t have to satisfy unneeded dependencies for action testing.

What pitfalls do you see in making this a standard practice? Have you tried this and found problems? I’d like to hear any criticisms and comments you might have.

ASP.NET Path With Virtual Directory

Michael Nichols — Fri, 18 Jun 2010 15:36:11 GMT

I needed to include a url in a confirmation email from my asp.net app. I am not sure whether it will be deployed to a virtual directory or its own site. Just getting the Authority from the Request will yield no virtual directory, so here’s what i came up with:

const string action = "Login/Confirm";
var uri = new UriBuilder(HttpContext.Current.Request.Url);
uri.Path = VirtualPathUtility.ToAbsolute("~/"+action);
uri.Port = -1;//remove :80 (use default)

var url = uri.ToString() //http://localhost/myapp/login/confirm

There is probably a better way of doing this, but it works.

Using Team City With Git

Michael Nichols — Sat, 12 Jun 2010 07:07:00 GMT

I love TeamCity, but I had some difficulty with setting up Team City with Git as my vcs so thought I’d log my configuration here. Documentation on the plugin is a bit sketchy and the exceptions raised when testing connections can be horrible, but the native Git plugin in Team City (v5.1+) is still under development so some features are still not completed so I expect things to be a bit rough around the edges.

Mode

I just wanted to my sources to be updated incrementally, being triggered by changes at the host. This requires having the build done on the agent (not the server):

Note this requires having git installed on the build agent server. Team City is smart enough to find git if you follow default installation of it, but I include git in the PATH for consumption in the build script anyways.

Settings

Now I need to configure what is getting fetched by Team City and setup ssh to talk to github (we host on a private repository there). All development happens on develop branch so I instruct TeamCity to checkout that branch after fetching the data.

Also I need to tell TeamCity about authentication:

Authentication

I believe TeamCity still only supports the ‘Default Private Key’ option. I had seen somewhere someone using a Private Key but I wonder if they were using the older git plugin hosted at github.

Anyways, the part that took me a while to understand was this note under ‘Authentication Method’ selection:

Valid only for SSH protocol and applicable to both fetch and push urls.

Uses mapping specified in the file C:\Documents and Settings\TeamCity\.ssh\config if that that file exists.

I run TeamCity under a user account called ‘TeamCity’, so this is just instructing me where the build agent will go looking when it is doing its work. It is important to note that passphrases aren’t supported yet. The ‘config’ file threw me because I don’t know anything about ssh. I thought that was what my key file should be named (eg. ‘id_rsa’) . The ‘Known Hosts Database’ checkbox is checked because I don’t want it checked…confusing? I thought so too…please don’t ever code an interface with a checkbox that has the label ‘do not check’ next to it. I thought this was telling me not to check the box…silly me! If you do check the box Team City will in fact create the ‘known_hosts’ database in the folder for you.

The ‘config’ file it is talking about can be simply:

Host github.com

Fetching

Team City explicitly fetches no tags (‘git fetch –-no-tags’). I use tagging to marking my versions so when my tags weren’t being found in my script I wasn’t sure what was going on since I knew the tags were on the remote repository. I thought for sure my n00b git skills were causing me pain. Jet brains confirmed that they are not fetching tags. This leaves two options:

Manually call ‘git fetch –-tags’ on the agent; what if I want to clean the directory and have it rebuilt? That seems error prone
Call git within my build script

I went for option 2 and that put me back in business with versioning my assemblies. I actually came across an ssh error so ended up adding this to my config file mentioned earlier:

Host github.com
StrictHostKeyChecking no

This seemed to resolve this error, but I am sure someone could tell me this is a bad idea. Works for now.

As an aside, you can see the command being fired by Team City by following instructions here.

I Hope this helps!

Removing Git Tag On Remote Repository

Michael Nichols — Thu, 27 May 2010 22:29:26 GMT

I needed to remove a tag from a remote repository @ github.

Here’s the command locally:

git tag –d <mytag>

Then this:

git push origin :refs/tags/<mytag>

Responsibility And Disaster

Michael Nichols — Wed, 12 May 2010 03:50:00 GMT

There is an interesting discussion going on over at a site that is discussing a web host provider that attempted a migration and made and epic fail. Consequently, there are reportedly multiple developers who have lost lots of money and professional credibility.

I went through this “migration” which would have been better performed by geese, but didn’t lose any money. I also work for a firm producing in-house apps and do a little side work.

It seems odd to me to place the entire weight of something like reputation or (reasonable) availability for apparently mission-critical apps on a web hosting provider, particularly if we are talking about shared hosting plans.

However, maybe I am naive.

Like I said, the side work I have done has been for small corporate sites – if they were down for a bit I couldn’t say my client was losing $200,000. If that was at stake, I would probably opt for a different hosting solution or at minimum have a path to follow in the event of disaster.

My take on these gripes is this:

Introducing a hosting provider brings in a new dependency and it seems like it is up to the developer to make clear who is the owner of that dependency. This at least should include good layman’s documentation if the client doesn’t want to pay for support of the site and the developer shouldn’t be so unwitting as to how the app is deployed as to be speechless when a failure occurs. The time to discover about domain registrations and DNS pointers is before the client is “losing money” on a website, I’d think. No matter who is responsible for what, it seems like a backup plan for applications which are so important (and those that may not be) should at least include a general guideline to redeploy to another provider. They aren’t really that different.

In one comment the complainant was just discovering what is involved in the transfer of domains and DNS records; he seemed to rely on the client to set all that up and never bothered to document retroactively. This kind of situation seems like an exposure of incomplete work to me, but I am willing to be wrong.

I’d really be interested in hearing others’ comments on this…