Using different credentials to connect to Team Foundation Server

Team Foundation Server, Tips and Tricks, Visual Studio No Responses »

Feb 192013

Recently, I had to authenticate to Team Foundation Server using an account with greater permissions to perform some administrative tasks. As you may know, this requires entering alternate credentials when you add the server to the list of TFS servers, or when you need to connect to the server. Once you’ve connected once, you aren’t prompted again as the credentials are cached locally.

In the past, to remedy this, you could simply delete the local TFS cache, which is located in the following directory (Windows Vista and onwards):

<system drive>\Users\<your profile>\AppData\Microsoft\Team Foundation

However, in more recent versions this has changed somewhat, and the user’s credentials are no longer linked to the local TFS cache or configuration.

Where are the Credentials?

Good question. After some digging about, it seems that the credentials are now stored in the user’s Credential Manager store within Windows. If you aren’t familiar with this, it was introduced on the more recent versions of Windows, and it lives via the Control Panel, under the following path: Control Panel->User Accounts

Inside this location, you can view all the locally cached credentials, including Windows Credentials:

Note: that it appears that for TFS credentials used by Team Explorer and other applications, the credentials are the ones under “Generic Credentials” not under “Windows Credentials” (in case you have TFS entries in both).

Making Changes

To modify or remove the credentials you use to connect to TFS, simply expand the appropriate entry and click on “Edit”, or to delete the local credentials, click on “Remove”. If you opt to remove the credentials, you’ll be prompted to enter new credentials next time you connect to the specified TFS server.

So that was a little out of the way. When I tested this, I made sure that I’d disconnected from TFS before changing/removing the credential configuration.

It would be nice if Team Explorer linked to the Credentials Manager so we didn’t have to go digging to work this out, wouldn’t it?

Team Foundation Server in the Cloud (Part 4): Builds in the Cloud

Cloud Computing, Team Foundation Server, Technology, Tips and Tricks 1 Response »

Jul 182012

The series so far:

Part 1 – Setting up TFS Azure
Part 2 – Configuring Visual Studio to use TFS Azure
Part 3 – Registering Team Build controllers for TFS Azure
Part 4 – Builds in the Cloud (this article)

Introduction

Following on from an earlier series of articles on TFS Azure comes this update. Recently, Microsoft integrated cloud-based build controllers to streamline the process of getting your automated builds online.

This is an excellent alternative to having to procure and configure your own on-premise build machine, and means that you can create basic build definitions with little overhead.

Where we left off..

In the previous article, we had configured an on-premise build server which hosted and performed local build services for our TFSPreview TFS instance. This was the only option in the initial release of TFS Azure as there were no cloud based build services available.

New Capability

I recently created a new TFS Team Project to allow some collaboration. I’d been in discussions last month with local Microsoft TFS expert Grant Halliday, he’d mentioned that there was now a cloud-based build controller option available.

Today I uploaded a very basic solution comprising of a console application and a Unit Test project. Adding the cloud-based CI capability was easy as pie.

Configuring Your Cloud Build Controller

Simplicity itself.

1. Once you have a valid solution in source control, simply right click on the Builds item in your Team Explorer and select “New Build Definition”:

2. Give your new build a name:

3. Configure the build trigger (notice all the regular options exist):

4. Next, set the build workspace(s) as per normal:

5. This is where it gets interesting. You configure the build defaults, but there are some interesting options when using the cloud-hosted build controller:

Note that “Hosted Build Controller” is in the list of controllers available. There is also an option which checks build output into source control (no need for a build share!)

6. There are also much the same options for the build process as you’d expect with an on-premise controller – and you can add your own build definitions as per normal. Note that there is a new definition here also – “AzureContinuousDeployment” which we might touch on in another article.

7. Once you’ve set your retention policy, you are good to go.

Executing a build

Treat it like any other build controller/build host! You can manually execute or (if you’ve configured gated check-ins or CI build definitions) just make some changes and commit.

You can even watch the building process in real-time, just like a non-Cloud-hosted build controller:

Summary

Couldn’t be easier! Obviously, if your build process or solution require any special steps you may hit a wall with the hosted build controller. This capability though, might be useful for selected branches of a large solution in which you wished to place gated check-ins/continuous integration, where the output is unit testing + classes.

All I can say is – this is a step in the right direction.

Team Foundation Server 2012 – Release Candidate (Installation) – Part 2

Pre-Release, Team Foundation Server, Technology No Responses »

Jun 022012

Introduction

Following on from the previous article, where I installed the Visual Studio 11 Release Candidate on a Windows 8 Release Candidate, I’m now going to step through the process to set up a complimentary ALM capability – Team Foundation Server 2012 (Release Candidate).

As per the previous article, links to the downloads for all products mentioned are listed in the following article.

Preparation

I’ve installed a copy of the Windows Server 2012 (Datacenter) Release Candidate as the host for my TFS installation. This configuration will not support SharePoint Foundation 2010 – so this is not a recommended configuration if you want to use Team Projects/Team Sites.

As I was preparing to install TFS, I copied the .ISO files across from my SAN, and noticed something interesting on Windows Server 2012 RC – the file copy dialog reveals a lot more information on the progress of the file copy operation:

Once you have mounted and run the initial TFS 2012 RC installer, there is an initial configuration of the base setup files, followed by the TFS configuration screen.

The initial option is to display the “Standard Single Server” configuration option:

Pre-installation

I’ve pre-installed SQL Server (so I can add reporting services later), but I’m going to use the “Basic” TFS configuration, since I won’t have SharePoint configured. If you also want to pre-install SQL Server, the configuration you are likely will require is per the below screenshot:

Once again, it is always a good idea to familiarise yourself with the TFS prerequisites which can be found in the TFS install guide which is found in the root of the TFS disc.

The Basic Configuration

Anyhow, continuing onwards – as I mentioned earlier, I’m picking the “Basic” configuration (I’ll do a series of articles on setting up a complete solution once Team Foundation Server 2012 goes RTM).

This leaves us with very few things to configure. Literally, all I need to do is decide whether I’ll let the installer use SQL Server Express, or to point at an existing SQL Server instance.

The configuration is verified, and once you hit the “configure” button, the configuration is executed:

Finished!

When the configuration is complete, you should be able to connect to TFS from Visual Studio 11 directly (no need to install Team Explorer separately!). In my case, I connected as an Administrator, but you would obviously want to create some users and groups.

In the next article

Now that we have Visual Studio 2012 connected to TFS 2012, we can create a Team Project and begin a project! I’ll go back and establish Reporting capabilities in a later article.

Older Entries

Featured Articles

A quick and dirty Rules Engine using Windows Workflow (Part 2)
Hi there and happy new year. 2011 promises to be quite an interesting year, and I hope that I can continue to contribute here at Sanders Technology. To kick off the new year, I decided to revisit the Windows Workflow article I started late last year. A little while ago I wrote a post at entitled “A quick and dirty Rules Engine using Windows Workflow (Part 1)” which has evidently been fairly popular. Unfortunately, it seems that I forgot to follow it up with a part 2! Now, welcoming in the new year, I’m putting together the second part. Honestly though, folks, this could easily be a multi part mini project, because the uses of this Windows Workflow Foundation (WF) [...]
A quick and dirty Rules Engine using Windows Workflow (Part 1)
Recently I put my mind towards developing a fairly light rules based utility for applying various logical patterns on top of some linear business data. Honestly, my initial thoughts were “oh no, not another boring rules based implementation” because we (ought to) know how boring that can be – and convoluted – but this time I decided to try something a little different. Through no fault of my own, I’ve actually had very little to do with Windows Workflow Foundation – WF, not WWF which stands for World Wildlife Foundation, and not to be confused with the World Wrestling Federation, just to avoid confusion! Most of the project I’ve worked on previously have used some other workflow product, usually something [...]
The ADO.Net Entity Framework, POCO Objects and You
Introduction Now if you are like me, you’ve probably had some interest in POCO (plain old CLR objects) objects for at least some time. They are an invaluable tool in the distributed systems and service oriented architecture areas, but up until now they’ve been inaccessible for those designs. In a nutshell, both LINQ to SQL and Entity Framework (v1) class entities did not support serialization for the purpose of stateless transport(such as web service communication). This stems from the embedded context tracking attributes, and the design which stipulates a fairly poor experience for those daring enough to detach entities and “pass them around”. Enter the ADO.net Entity Framework v2.. ahem, version 4 which shipped in the early part of this [...]
A Dynamic Data Website with SQL Azure and the Entity Framework
This is part of a series of entries written about Microsoft’s new SQL Azure database service and the Entity Framework v4. Following on from my previous posts (check them out before continuing) – this article assumes you have followed steps outlined in the previous posts to create various models and accounts etc. Part 1 – Working with Entity Framework v4 and SQL Azure Part 2 – Next Steps with SQL Azure Part 3 – Putting it all together – SQL Azure Part 4 – A Dynamic Data Website with SQL Azure and the Entity Framework (this post) Addendum – Getting a SQL Azure Database Continuing along.. Our next step is to create a Dynamic Data website. If you haven’t come [...]
Putting it all together – SQL Azure
Happy Australia Day to you! Following on from my previous posts (check them out before continuing) – this article assumes you have followed steps outlined in the previous posts to create various models and accounts etc. Part 1 – Working with Entity Framework v4 and SQL Azure Part 2 – Next Steps with SQL Azure Part 3 – Putting it all together – SQL Azure (this post) Part 4 – A Dynamic Data Website with SQL Azure and the Entity Framework Addendum – Getting a SQL Azure Database Now we should have a working data model which has been created in your SQL Azure (Cloud) database. Taking lessons learned from Part 2, we’re going to create an Entity Framework (v4) [...]
Working with Entity Framework v4 and SQL Azure
This post is the first in a series of posts on this topic. The following is a summary of the various parts. Part 1 – Working with Entity Framework v4 and SQL Azure (this post) Part 2 – Next Steps with SQL Azure Part 3 – Putting it all together – SQL Azure Part 4 – A Dynamic Data Website with SQL Azure and the Entity Framework Addendum – Getting a SQL Azure Database Introduction Well, it’s been “out there” for a while, and now it is time I gave you a taste of how to combine some of the “Next Generation” data access technologies, today. SQL Azure is Microsoft’s “Database in the Cloud” and represents a complete makeover (replacement) [...]
Functional Transparency: Part 2
This is a little late – but I feel it is worth going into and you can catch up be reading (or re-reading) Part 1 located here. Just in case you are wondering “what on Earth is he babbling on about?” which is a fair and often under asked question, here’s a brief summary to refresh your memory. The objective is to implement additional (background) functionality which is not seen by calling/consuming code – hence, transparent. In fact, it’s even possible to enforce execution of certain functionality no matter how a DataContext is manipulated – neat, huh? So let us look at a simple database table and let us further assume you have generated a LINQ to SQL Model: SQL [...]
Functional Transparency with LINQ to SQL (Part 1)
I’m going to coin the phrase ‘Functional Transparency’ because it fits the definition. I’ve been working with functional transparency in LINQ to SQL for a few weeks now, and it seems to be working well enough to write about. The objective is to implement additional (background) functionality which is not seen by calling/consuming code – hence, transparent. In fact, it’s even possible to enforce execution of certain functionality no matter how a DataContext is manipulated – neat, huh? In other words, we implement additional functionality between the DataContext, its entities and the Database itself. Our objective may be to modify the data returned from a query (or data saved to a database), might be to audit operations or even check [...]
Intelligent Paging using LINQ to SQL and the LinqDataSource control
Undoubtedly, anyone who has evaluated LINQ to SQL has fond it a fairly powerful yet lightweight ORM technology which is less complex than the ADO Entity Framework yet utilizes the strength and power of Language Integrated Queries. One problem with LINQ to SQL is the auto paging feature of the LinqDataSource. Below is a rough GridView which displays three columns, UserName, FirstName and LastName. This is just a rough demo, so we’re looking at paging. If you simply drop a GridView and a LinqDataSource control onto a Web Form and configure the LinqDataSource (using Smart Tags) without specifying a Group By field or Order By field (Figure 1) then you will get fairly optimal database querying (Figure 2) although [...]

« Previous Post Pause Next Post »