Eric Hexter

Using MSDeploy to automate your Enterprise Application remote deployments.

erichexter — Fri, 06 Nov 2009 17:00:00 GMT

MsDeploy is a newish technology that is a bit schizophrenic. What I mean is that it is a tool that is useful to both Developers and Administrators but it is not clear from the documentation how to best use the technology and how to approach it. I believe it stated as a Server Administrator tool and the team was able to work in an integration with Visual Studio which made it into a more robust framework, but at the same time left is command line interface with so many options that it is challenging to get a grasp on. To top that off the Web Platform Installer uses the MsDeploy packages as a way to distribute packages through that tool. After working through some various ways to use the technology I have settled into some commands that work well for our projects.

Let me set the context of how we are using the tool and what we already had in place so that you can better understand if my use of MsDeploy will work for you. At Headspring we use Continuous Integration on all of our projects and as a result, once our software is built by our build server the next logical step is to deploy our software to a server and than run User Interface tests against the application. Most of our projects are web applications running on ASP.Net MVC using Sql Server as the back end. We install our software using a lightweight zipfile that contains the web application files, database migration scripts and a deployment script which can poke config files and execute our database migration tool. We already have all the pieces in place to deploy our application on a local machine.

Up until know we have used two methods to deploy instances to remote machines. The first methods was to install Cruise Control.Net on the server and have it monitor our source control repository for a new installation package being committed to the repository. Once it sees a new package CCNet will pull down the package, install it locally and go on its merry way. The second method, is to kick off the deployment from the build server and connect over the network to the target database to run upgrades and then xcopy the files to a unc share. Both of these methods require setting up some configuration on our target servers. My goal with our deployments is to reduce the amount of per server configuration we do on each server and use some conventions to make each server look similar to one from a different project.

Using MSDeploy allows us to do the following.

1. Remove the need to install cruise control on the target server and update the configuration for cruise control on each target server. We do have to install MSDeploy on each server but we do not have to mess with any configuration after that.

2. We do not have to mess with setting up unc shares and deal with the mess. It sounds like a silly thing but by getting away from the unc share we can also test our deployments from any machine and msdeploy is actually firewall friendly. xcopy to a unc share is not firewall friendly which means that we cannot use it for all of our clients which means variations between our projects.

3. We use msdeploy as a mechanism to distribute our deployment packages and then remotely execute the packages. This means I can have a single instance of our Continuous Integration server which reduces the number of places to maintain configuration. That is a big win. This also means the log files for all of the deployments can be tracked in a single place.

4. Another benefit of using msdeploy to push our deployments means that I can easily setup new instances of a test configuration and push it to multiple servers without having to log into each machine.. This is good for efficiency.

Our use of MSDeploy now boils down to two steps. Distribute and Execute. We have some of our scripts in NAnt and we are in the process of migrating to PowerShell now that version 2.0 is available from the older operating systems. Below is a sample of executing msdeploy from a NAnt script.

Calling MsDeploy from Nant

The dirPath command tells MSDeploy to synchronize a directory from the source computer a target computer. This is a pretty easy command to understand.

The second command is the runCommand this command was added between the RC and 1.0 release of MSDeploy and I am so happy they added it. The run command is told to execute a command on the remote machine. Since we are running installation scripts, they do not execute instantly and as a result the waitInterval and waitAttempts need to be specified so that the command does not timeout before it has completed running. other than that the output of the console application is piped back to the source computer. The one caveat about the run command is that when it starts it runs from the C:\windows\system32 directory. In order to work around this issue I have found that passing the directory of the command into the batch file that I run allows my batch files to first cd to that directory as its first step. This is a pretty harmless thing to do and works pretty well.

This is what a sample deployment batch files looks like.

cd %1
rd ..\codeToDeploy\ /s /q
applicationNamePackage.exe -o..\CodeToDeploy\ -y
cd ..\CodeToDeploy\
cmd /c %systemroot%\system32\inetsrv\appcmd stop site applicationName_dev
iisreset
call dev.bat
cmd /c %systemroot%\system32\inetsrv\appcmd start site applicationName_dev

This is pretty basic and does some IIS commands as well.

I am sure I left some information out, but I wanted to get a brain dump of our use of MSDeploy.

Long term I would like to see the use of PowerShell driving msdeploy and adding some configuration around each Server Role in an application and tie it to the servers needed for each environment. I have started a project to put this together called psTrami but I have not put any of the code together yet, just some small spikes to prove it out.

More to come sometime soon…..

Automapper Auto Profile Registration.

erichexter — Thu, 05 Nov 2009 03:24:15 GMT

On some of our projects we have been experimenting with smaller AutoMapper profiles. The idea is that it is easier to digest a smaller profile. We have gone so far as creating a profile for each Domain object and handle all of the mappings to and from the domain object. We are also trying out a Profile per scenario. While these smaller profiles are easier to dig in and understand, the registration of them are a little painful. So I put together a quick way to auto register all the profiles for automapper. Below is the code to discover all the profiles in an assembly than register them with AutoMapper. There is nothing fancy here and I could certainly spend more time making it better performing, but realistically this is startup code that runs once at application start up. That being said I would rather focus performance optimization efforts on places that actually make a difference to the End User Experience.

Here is the sample.

It is important to know that we have full code coverage over our application including integration tests, so that if something were to break as a result of loading this in a non deterministic order, we would know before we commit our changes to source control.

Here is the code for the ForEach extension method, since I breezed over it.

This is a smaller post than I normally put together.. is this small of a post useful?

ASP.Net MVC Portable Area – Part 4 IoC framework support.

erichexter — Wed, 04 Nov 2009 05:00:00 GMT

Part 1 – Introduction
Part 2 – Sample Portable Area
Part 3 – Using of a Portable Area
Part 4 – Using an Inversion of Control Framework. (this post)

Using an Inversion of Control Container is a common scenario that would be needed by a Message Handler. The Bus has an extensibility point to create the handlers. The model for this should feel similar to the ControllerFactory extension point in the ASP.Net MVC framework. The sample below shows how to create a Message Handler factory for the StructureMap framework.

The SetMessageHandlerFactory method should be called once at application startup. Other than that … this is a pretty simple way to add a Dependency Injection Framework support to the Portable Area infrastructure.

This makes it pretty simple for your message handlers to use constructor injection to manage their dependencies.

ASP.Net MVC Portable Areas – Part 3

erichexter — Tue, 03 Nov 2009 17:00:00 GMT

Using a Portable Area

This is the third part in a series about using a Portable Area (PA) using MvcContrib. This sample walks through the Host Application side of consuming the Login Portable area. This example demonstrates how a portable area such as a login can send messages and recieve responses from the host application. This allows the host application to control the core of the application and lets the Portable Area solve the User Interface portion of the Login. While this is a pretty simple example it is important to look at the concept of what a Portable Area could solve. A portable Area could just handling wiring up multiple user interface screens and deal with simple form validation while leaving a lot of from for the host application to control the parts that are important to the application. Or a Portable Area could provide an entire self contained piece of functionality like a Blog engine, or mulit-instance forum. There is a large spectrum for how much the Portable Area could provide. This example focuses on an example where the Portable Area provides the UI and lets the host application own the domain logic.

Part 1 – Introduction
Part 2 – Sample Portable Area
Part 3 – Using of a Portable Area (this post)
Part 4 – Using an Inversion of Control Framework.

In order to use a Portable Area (PA), the following references need to be added to your MVC project: MvcContrib & the assembly of the Portable Area.

Wiring up the Portable Area to the application is done at startup. Portable Areas use the message bus as a way to communicate between the PA and the application. The main method for integrating with a portable area is to register a Message Handler. The sample below demonstrates wiring up a LogAllMessagesObserver, LoginHandler, and a ForgotPassword Handler for the Login Portable Area.

The call to the InputBuilder.Bootstrap() is required to initialize the Embedded Resource view engine used by this Portable Area infrastructure.

Here is an example of an Observer message handler. This handler simply logs the message to the debugger. This could be used to collect metrics about the system, or log messages to a loggin framework. The idea of an observer is that it is looking at the base message and not modifying the state of the message.

The Login Message Handler receives the login request and than sets the result object which is part of the contract that is specified by the LoginPortableArea from Part 2.

In this example the main logic for login is still in a authentication service. The handler is just used to wire up the message and response of the portable area to the host applications domain services.

Whats Next?

The constructor of the LoginHandler takes an IAuthenticationService as a dependency and my next post will walk through how an Inversion of Control container can be connected to the Bus to allow the framework of your choice to put your pieces together.

ASP.Net MVC Portable Areas – Part 2

erichexter — Mon, 02 Nov 2009 17:00:00 GMT

Sample Portable Area

This is the second part in a series about creating a Portable Area (PA) using MvcContrib

Part 1 – Introduction
Part 2 – Sample Portable Area (this post)
Part 3 – Usage of a Portable Area
Part 4 - IoC Framework Support

To create a Portable Area, the first step is to create a separate class library project for the Portable Area. The output assembly is the single file needed to add this functionality to applications which wish to consumer it.

The minimal references required for the Portable Area are shown below:

While DataAnnotations is not required to build a PA, using DataAnnotations for Model validation makes distribution of the PA very easy, since the MVC2 DefaultModelBinder supports the DataAnnotations validation out of the box. If you choose a different validation framework than you would need to distribute those assemblies or possible IL Merge them into your PA.

The sample PA in the MvcContrib project is a Login Portable Area, this is a pretty simple example, but demonstrates how a PA and application can integrate. This is also a piece of functionality that most applications need.

Below is the code listing and structure for the project. It looks identical to a mulit-project ASP.Net MVC Area.

The first difference between creating a Portable Area and a standard area from the files perspective is how the Views are registered with the project. The views Build Action should be changed from content to an Embedded Resource. This allows the views to be embedded into the output assembly so that they view folders and files to not have to be manually copied into each application that uses it. Instead a special view engine will pull these views out of the assembly at run time and render them the same way that a physical view would be rendered.

The second item that is needed to create a Portable Area is a specialized registration class for the that inherits from PortableAreaRegistration. This class provides an extended RegisterArea method that sends in the MVC AreaRegistrationContext and a IApplicationBus object to the method. The IApplicationBus is the mechanism that a Portable Area uses to send messages to the hosting application during. The use of the bus during registration is not required, but it is available in case and specific start up logic is needed to correctly configure the Portable Area.

The last line of the method show how the Portable Area registers the embedded views with the view engine, using the call to the RegisterTheViewsInTheEmmeddedViewEngine method.

An important caveat around the setup of the Registration class is to make sure that the Registration class is sitting in the same Namespace as the controllers and views. If the Namespaces do not match the views will not be able to be located. Since the namespace for the Embedded Resource views cannot be specified declaratively they are created using the Assemblies Default Namespace and the folder structure that they are stored in. So keeping all of these properties consistent will make everything work. If you change the default namespace of the project, you will need to update the namespace of your registration and controller classes.

The first call in this registration method sends a message to the hosting application. This is a contrived example but it demonstrates sending a tracing message that can be used by an observer message handler to log the registration activity. This tracing can be useful since the Portable Areas use the built in MVC registration mechanism for auto discovery and there is not a lot of visibility into the built in registration process. This example shows how a message can be sent between the PA and the hosting application.

The LoginController demonstrates the functionality needed to handle displaying the login form and then handling the form post. There are two Actions in the controller, one to render a Login View and a second Action to process the form post and redirect the user on success or , in the case of a login failure, display the login error messages to the user.

The message bus is the main mechanism for communicating between a portable area and the hosting application. This is a very simplistic mechanism that allows the Portable Areas to communicate with the hosting application in a synchronous manner.

For some scenarios, like when the area should not implement its own database, the host application can own how the domain model is persisted in data storage and the Portable Area can worry about handling the multi-page user interface and other user interface concerns like validating simple data types.

The messages that are passed to the Bus are shown below.

The LoginInput represents the data that is collected from the Login screen. It is using the built in DataAnnotations attributes to handle the simple validation rules.

The result object is used to determine if the credentials were valid for the host application and are then used to either display the error message or redirect to a protected page. Since the LoginInputMessage is passed to the bus with a reference, the handlers in the host application can change the Result object's state and the portable area can than access the Result and determine the correct logic to perform given that result. The implementation for the handlers will be in the next post in this series.

The Index view for the login uses the MvcContrib Input Builders to render a standard form to the page. The use of the Input Builder allows an host application to override any of the html mark up using the Input Builder partials. This means that the Portable Area and Input Builders play very nicely with each other.

This is what the view looks like in a browser.

This is the validation errors that are handled by the Portable Area, using the MVC 2 default model binder.

This shows an error message that is passed back from the resulting application. Other rules could be applied as well.

This is the approach for creating a Portable Area (PA) using the MvcContrib Portable Area feature. Let me know what you think about this approach, we tried to stay with the simplest approach that could possible work, and focused on making it easy to both develop and consume the Portable Areas.

Please leave your comments on what you think of the approach.

ASP.Net MVC Portable Areas via MvcContrib

erichexter — Sun, 01 Nov 2009 18:00:00 GMT

This is a multi post series on ASP.Net MVC Portable Areas

What is a Portable Area?

A Portable Area is a set of reusable multi page functionality can be dropped into an application to provide rich functionality without having to custom build functionality that is literally the same in every application. This could be considered a plug-in or add-in type of functionality. The portable portion of this approach is that the area can be distributed as a single assembly rather than an assembly and a host of other files, like views or other html assets that need to be managed and maintained over time. By making a portable area totally self contained in a single assembly, this should allow for easier reuse and upgrades to the area. The challenge for doing something like this has been how do you allow enough control over the User Interface by the application yet still allow the actual views to be packaged with the logic.

Why Now?

There has been some discussion in the past on the MvcContrib mailing list about creating an plug-in framework and plugins but I do not think we had enough of the pieces in place to do this properly. I believe that with MVC 2 we have those missing pieces figured out. The first enabler is the inclusion of Areas into the MVC 2 feature set. This includes having the Area and Controller namespace become part of the route data which is used both for Controller/Action selection but this also flows down to the selection of a view. The second enabler is some of the work that came out of MvcContrib and the Input Builders. While implementing that feature we came up with a way to pull views from an assembly as an embedded resource. This with the ability to override the default view engine in a way that allows an application developer to place their own version of a view in a folder so that they have the option to change the view to their needs was huge. The last enabler really comes from what we have learned from all of the SOA greats and see how frameworks like nServiceBus and MassTransit have demonstrated that a messaging approach for integration can keep our concerns separated.

The other why now is that my company, Headspring, has found that in order to make our practice more successful, we need the ability to drop in some of the essentials for an application, we would prefer to do this in a binary form that is easy to upgrade and does not leave us with copy and pasted code between our various projects. We would like to see that if we learn something from one project that we have the potential to apply those learning's to projects that are still in flight. We all prefer that rather than waiting for the next project to start so that we can apply what we have learned to the new project. This approach will be much better for us as developers and our client will benefit as well. We could take the approach of working on this in a bubble but by putting this out for the community we can learn from every else and potentially help others in the process and raise the collective bar for the industry, in our own little way.

Logical View of a Portable Area

Below is a logic view of a Portable Area. It shows how the Green block is an application. Inside the application the blocks in dark blue are framework components in ASP.Net MVC 2 and MvcContrib. These blocks provide some minimal framework support for registration view resolution and communication between the application and the portable area. The light blue blocks represent code the developer create. The code in the Portable Area is created by the Portable Area developer. The code in the application block is coded by… you guessed it. The application developer.

Thanks for the Pictures but where is the code?

The code is currently available in the MvcContrib MVC 2 Branch. You can get the latest binary from our (TeamCity/CodeBetter) build server here: http://teamcity.codebetter.com/guestAuth/repository/download/bt83/.lastSuccessful/MVCContrib.release.zip

There is a sample application you can download here: http://teamcity.codebetter.com/guestAuth/repository/download/bt83/.lastSuccessful/MVCContrib.Extras.release.zip

or from the code repository on GitHub: Download the source as a zip. or Fork it on GitHub.

What I have been up to.

erichexter — Fri, 30 Oct 2009 03:36:02 GMT

I have been pretty busy over the last few weeks. I just wanted to document what I have been doing.

I co-presented a free Advanced ASP.Net MVC half day with Jeffrey Palermo in Austin. We had a good group of people show up to the Austin Microsoft office. As I was preparing and presenting the session, it has become very obvious how much

I co-presented with Jackson Harper from the Mono team at Monospace on Mono and the Web ASP .NET MVC, WebForms, Tools, and Servers. In preparation for this session I took the code camp server, codebase and got it running with Mono on openSuse… yeah that Linux, That means that ASP.Net MVC, StructureMap, NHibernate, Automapper, Castle Validators, and MvcContrib all work on mono and are binary compatible! I was able to compile the application in Visual Studio and using the MonoVS plugin deploy a vm. We also demonstrated ftping the bits to a Linode and Jackson showed how to get is all setup. He even made a Virtual Appliance that when you start it up in vmware it will be running the application on the web server.. You can get the slides, link to the mono version of the source code, download the virtual appliance from the mini site that was setup for the talk. http://MonoOnTheWeb.info . I thought it was pretty cool seeing all of this stuff work. It was a great way to prove out that the application stack that Headspring uses can be deployed on a wide range of platforms which ultimately opens up our potential customer base.

I had the chance to present Database Change Management as the InnoTech conference. It was pretty good to get out and see a group of people that I have not seen before. I sometimes feel like I am in the Austin .Net bubble so while I presented some code samples in .Net using SQL server I really tried to present the information as being agnositc of you database platform. Good development techniques can transcend technology and platforms.

Video of the Continuous Integration workshop

erichexter — Fri, 18 Sep 2009 00:03:33 GMT

Early this week we ( Jeffrey Palermo and I ) gave a Continuous Integration Workshop in Austin. We were able to record the workshop and our company Headspring Systems made the recordings available on their website. There is just under 3 hours of video covering the following topics:

reducing risks using CI
automated builds
automated deployments
building software at every change
continuous database integration
continuous testing
continuous inspection
Software Configuration Management (SCM)

These are not professional videos by any means, but there seemed to be some interest in hearing how we do ci. I am personally excited that we have these videos because it will help me improve how I present this information in the future.

You can view the videos and download the slides from here:

http://www.headspringsystems.com/services/agile-training/continuous-integration-boot-camp/

Enjoy!

Continuous Database Integration - video

erichexter — Thu, 17 Sep 2009 19:50:53 GMT

At the continuous integration workshop Headspring Systems held in Austin this week one of the topics that we covered was Database Integration. We are still in the process of publishing the videos of the entire workshop but I thought I would publish this snippet (30 minutes) that talks about how We Do Database Migrations. Jeffrey Palermo and I did this workshop and had a great time doing it. This demonstrates how to use the Tarantino toolset.

I hope this is useful and would love to hear some feedback about what you like or hate about this approach.

Video of the David Ebbo presenting T4MVC to the Community For MVC virtual user group

erichexter — Thu, 17 Sep 2009 03:46:15 GMT

David Ebbo presented to the Community For MVC group today. The topic T4MVC which is a project that David developed as a way to eliminate the magic string in Views and Controllers in the ASP.Net MVC framework. David walks through a sample of adding his code generator code to the Nerd Dinner application and walks through removing the magic strings and replacing them with strongly typed replacements. I like his approach because it solves a pain that I have when using a Lamda based approach to eliminating the strings in views.

David does a great job walking through what the problem is and than goes through each of these and shows how his approach solves this problem. The meeting was held in Live meeting and we are experimenting with this as a way to let developers interested in advanced topics get a chance to hear new approaches and ask questions live. The video missed the first minute or two of the presentation and we had some technical difficulty near the end so I edited the video to keep the video clean. enjoy!

If you are interested in the Asp.Net MVC framework I encourage you to check out Community For MVC for future presentations. This group is focused on delivering advanced topics that help with developing solutions on the ASP.Net MVC framework. There is a mailing list on the website and that is the best way to get notifications of upcoming meetings.

Community For MVC – Virtual Meeting – Wednesday 9/16/2009 12:00 - 1:00 PM CST ; T4MVC presented by David Ebbo

erichexter — Mon, 14 Sep 2009 18:16:19 GMT

Link to the meeting information here: http://bit.ly/uj9VA Please feel free to share this link on twitter, blogs, ect.

David Ebbo on the T4MVC project - Wednesday 9/16/2009 12:00 - 1:00 PM CST
Join the meeting here: http://Meeting.c4mvc.net

Bio: David is an architect on the ASP.NET team, which he was a part of since its very beginning in 1998. He has worked on many areas of the product, though his particular focus has been on the compilation system. More recently he has been working on ASP.NET Dynamic Data, and exciting new feature which aims to simplify the creation of data-driven web sites.

Topic: David spent some time looking at how to reduce the noise in MVC views using some code generation technologies built into Visual Studio. He did this work and published through a series of blog posts.

Homework: Read his first article to understand the problem he was trying to solve. The solution proposed in the first blog post changed dramatically so please read on to the additional posts. http://blogs.msdn.com/davidebb/archive/2009/06/01/a-buildprovider-to-simplify-your-asp-net-mvc-action-links.aspx

This is a list of the most up to date articles to see how this work has evolved: http://blogs.msdn.com/davidebb/archive/tags/T4MVC/default.aspx

You can download the T4MVC bits from here: http://aspnet.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=24471

Free Continuous Integration Workshop in Austin Tuesday Sept 15th 1pm-5pm

erichexter — Thu, 10 Sep 2009 21:32:15 GMT

I am doing a Continuous Integration Workshop next Tuesday. The admission is free and will be held at the Microsoft Office.

To register go here: http://www.headspringsystems.com/services/agile-training/continuous-integration/

This will cover the basics of what continuous integration is as well as the the advanced techniques like Database Configuration Management / Continuous Database Integration. At Headspring we implement CI on all of our projects and we can provide some perspective on applying CI to .Net applications. If there is anything of particular interest you would like to see at the workshop please feel free to comment below.

If you cannot attend this workshop I encourage you to read this book: Continuous Integration: Improving Software Quality and Reducing Risk and have a conversation with me.

See you then.

Breaking changes in Ncover 3.0 integration with Cruise Control .Net

erichexter — Mon, 31 Aug 2009 20:31:02 GMT

There were some changes to the nCover xml reports for code coverage which will break your existing integration with cruise control .net. Specifically if you use the Statistics feature of Cruise Control which is one of the best features it provides IMHO, the xml nodes have changed and ncover no longer provides the total percent of coverage of the project as a single xml Node (or attribute). This means that you need to do a little more work..(not much) in order to have your code coverage collected as part of the ongoing statistics inside cruise control.

You can view the statistics through this link on the project page inside the CCNet Web dashboard.

The coverage is not being collected with the new version of ncover…

Here is the ugly side of Cruise Control .Net.. The xml configuration. I know it is ugly and painful to deal with… The line underlined is the new xpath selection for code coverage.

The old xml node for selecting the coverage was a firstMatch element, that must now be a statistic element. The old xPath must be replaced with this horrible statement which calculates the percentage of code coverage for the project. It helps to know that VSP = Visited Sequence Point and USP= Unvisited Sequence Point. Once you know that the rest falls into place.

Once the data is collected it falls into place and shows up in the trend chart….

Windows 7 Virtual PC FTW (For The Win) for virtual workstation development

erichexter — Tue, 25 Aug 2009 12:00:00 GMT

I have constantly fought both Virtual PC and VM Workstation when working on virtual machines for development purposes. While VMWare had the features I liked it also had a price tag and a rather smug attitude. I usually ended up having to use the free version of VMWare which was crippled or Virtual PC which was not much better. Both were missing features that I wanted.

Now that I am using Windows 7 on my developer laptop I figured I would put the Virtual PC through its paces and see if they finally solved my pain points. At this point is has been over a week and I am sold on Win 7 and virtual pc.

1. Removed the annoying system tray application.

I know it is pretty nit picky but I just bothered me that I needed to run that little system tray application. That is gone now and when you go to your Virtual Machines it shows you all of them and the location that they are running from windows explorer.

2. Support for my USB devices

One of the uses for my Virtual PCs is to have a virtual machine that works with some of my devices like video camera or x10 that I want to work on a moments notice after I repave a machine. Virtual PC did not support this so I had to do this in VMWare before. See the USB menu and the Attach menu items below.

3. Connect to the Network over my Wireless Connection

This one was a real pain to deal with. VM Workstation could do this out of the box. Virtual PC would not. There was a work around where you could install a Loopback adaptor on your host machine and do some route commands to make the network work properly but it was a pain and not portable. No when I teach the Headspring Agile Bootcamp or other classes I can share the main setup for our Continuous Integration server over our wireless network. This makes it real easy to start the class and run this virtual machine from my machine or say copy it over to a machine on the network. Since we teach the class at different venues having this different options really help.

4. Access local drives

This seems like a pretty basic requirement but before Virtual PC had it but the free version of VM ware did not have it. The work around was to map a network drive but it was so slow.

What do you like or hate about Virtual PC?

MvcContrib source code has moved to GitHub

erichexter — Sun, 23 Aug 2009 14:20:58 GMT

We recently moved the MvcContrib projects source code over to GitHub. We are hoping that the ease of creating forks and pulling them back into the trunk will allow for more contributions to the project. I know that GIT seems to be a source control system that few developers in the .Net space seem to know about but Jeremy Skinner created a great tutorial specifically for the MvcContrib project.

Here are the sections of the tutorial

Continuous Integration is running on the Codebetter TeamCity server. Codebetter and Jetbrains have teamed up and are providing free build server for opensource projects. Below is the MvcContrib builds, we currently have 3 builds running.. the old Subversion source. the new Git Hub trunk, and a branch on GitHub that is compiled against the MVC 2 ctp. If you want to download the binaries you can do so by accessing the artifacts from the build server. When you go to the team city server it will prompt you for a login. Select the Login as Guest option.

The build server is located here http://teamcity.codebetter.com/project.html?projectId=project10

The MvcContrib home page is still located here: http://MvcContrib.org