We have a dev team in asia with tfs and one in US. We would like to have another tfs in US and sync both of them in real time. Each of them can serve as the fail over cluster for each other.
Going forward we want to have teams login to respective server.
How can we achieve replication in real time ?. How does merge and collision be dealt with?.
We have proxy already but we want something better than that.
No, you can't replicate TFS in real time. You need to backup database and restore it on another server to have full migration. Or use tools like TFS Integration Tool to migrate work items or changesets (data lossy migration).
Using Visual Studio Team Service maybe a good option for your scenario. Visual Studio Team Services provides a set of cloud-powered collaboration tools that work with your existing IDE or editor, it's not needed to set up on-premise TFS.
Get database guy in the picture and ask him how to replicate and sync DB severs. Source code and change sets are stored on SQL. This should help you to proceed further.
My team is considering doing branch-per-task development in TFS 2010. We are thinking of using shelvesets for small tasks (1-3 days) and creating new branches for anything larger (4 days to 2 months). Once development is complete on the branch it will be merged to main and deleted (not destroyed). Typically it will be only one developer working on a particular branch.
Does anyone have experience working on a project using TFS 2010 with many branches. How did it work? Were there any server performance issues as the number of branches grew? Does it affect the performance of the VS IDE at all?
There are already many answers out there relating to questions such as "TFS sucks at merging and is crushing my soul, what can I do?" and "Why would anyone ever use TFS when x, y, and z are available?" Please try to keep your answers relating to server performance and usability of the system in the presence of a large number of branches.
Here is some background with my history of branching. The project I worked on previously used a branch-per-task strategy with ClearCase and it worked very well. Branch creation was tied to both the defect tracking and build system. Developers completed units of work each in their own branch. The lifetime of each branch varied from a day up to a couple of months. At the end of each task the code was merged into the main integration branch. This was a large project and after approximately 10 years of development the system has over 10,000 branches. ClearCase is able to handle this volume of branching quite well (except when viewing popular files in the Version Tree Browser, load time could be slow).
Basically the model you describe is a Branch by Feature, this is the model that the Dev Div of Microsoft uses to develop the Visual Studio product family, so you can tell it scales pretty well with TFS.
I recommend you to read this blog post and you can read the Branching Guide V2 to get more information.
As for the merging, the topic was pretty well covered here and on the web, in my opinion it doesn't suck when you use it correctly (and without the default merge tool).
I currently work in a company that uses FogBugz for issue and bug tracking and SourceGear Vault for source control.
We are now introducing Team Foundation Server. Clearly TFS will replace Vault for source control. My question is, with the following requirements:
Large existing base of FogBugz cases (some obviously open) that we need to support ongoing
Support desk needs to be able to raise bugs / support calls
Want changes to source to be linked to a case number
... what is the best split between using FogBugz cases and TFS WorkItems?
Is it possible to totally migrate from FogBugz to TFS?
If it is not possible to migrate from FogBugz to TFS then what is the best way to use the FogBugz case and TFS workitems together?
Initially I'd say bugs and defects stay in FogBugz, stuff on the project plan as work items. You could manually get the developers to create a work item for each case in FogBugz and associate the code with that work item but I can hear the howls of derision already :-)
You might want to take a look at the TFS Integration platform. I don't know if there are any tools that link directly to FogBugz but these tools are highly extensible. You could then decide to either migrate everything in to TFS or run both systems and synchronise. Running both is nice as each discipline can use the tool they are most familiar with, devs use TFS for everything and the testers / support can continue to use Fogbugz and the toolkit keeps everything in step.
I finally was able to complete the installation of TFS and started the creation of my first team project which introduced me to the process template.
After following to the link to Microsoft's site for process template information I was inundated with new information to consider. What templates have all of you had experience with that either worked out very well for you or were more of a stumbling block to the project? What were the biggest advantages and disadvantages you've encountered?
Some information about my project, I'm the lead developer for a small company and will be using TFS/VSTS to create an intranet portal to consolidate the end users day to day and increase automation to enhance productivity etc. It's entirely new development taking advantage of C#, ASP.NET and SQL Server 2008.
Ideally I'd like to take advantage of features to enhance collaboration with the stake holders to help add desired features and to track the status of development and offer feedback etc. I was also looking to take advantage of JetBrain's TeamCity for my TFS so if any specific template / software really adds cohesion between TFS, TeamCity, Developers, and Stakeholders that would be ideally what I'm interested in.
Are you already using a software development process like scrum? If yes you can try this Team Process Template over here.
How large is your project team and the project? Microsoft has published one of it's internal Process Templates (MPT) over here. You can get some guidiance and inspiration from this template.
As tangurena mentioned. People use the standard templates, change the bug a bit and store some documents there. I would recommend to keep the process 'light' as well.
However the process template isn't all.
Here are some ideas what I would do (in your case):
Create some high order workitems (features/stories) which stakeholdes can create (constraints and TFS user groups are your friend). They can then access their requested features via the TFS Work Item Web Access. That way you don't need a CAL for them
Create some reports which show planned work accodring to releases.
Setup the build automation and create Reports (a.k.a. Release Notes) from your workitems according to the builds.
What were the biggest advantages and disadvantages you've encountered?
Imho the biggest disadvantage is that you start believing that the template is your silver bullet. It's not, it's your starting point.
The TFS ecosystem offers you alot opportunities to create own bits of software that fit your needs. Just check out the TFS API.
Here is another nice agile-based template (original is on SSW, but you have to get around a login wall).
This template helps enhance cohesion between developers, managers, and other stakeholders by including more robust support for project process (documentation, reviews, &c., &c.). For example, there are types built in for process elements like release plans.
In general terms, I'd favour as small a process as you can manage. The more states, the more fields you have, the more likely the information in them is just plain wrong.
We're running with our own version on the Agile template. Most of what we did to it was delete stuff.
You can use the TFS API to log builds into the database, which should enable you to bridge TeamCity and TFS. Other than that, I'd probably just go with the web interface that comes with TFS, I don't think you need third party software for this.
K.I.S.S.! I created a custom work item based off the Agile one. And thats it, just one work item. There is a "System Severity" that IT uses and a "Business Priority" that the client/customer uses. There is also a "Request Type". With those three along with the built in Area and Iteration the entire team, including the clients can query the work items to get only the items they care about for the release they are concerned with (or all of them regardless of the release).
I did not modify the state machine much at all. This left us with something that is very flexible for everyone. Everything from blue sky requests to the mundane content/visual bugs can be logged there.
The client uses TFS Web Access (unlimited CAL) and the devs (me and 1 other) use VS. At my last job I created the same setup, the dev team was a team of 5 and it worked even better there! I was dev lead there as well and technical PM.
The biggest advantage was having a very flexible system for everyone, when using 1 work item type for everything. The disadvantage would be a learning curve for the client, but once they knew how to use it most like it. A suggestion would be to look into cheaper tools out there for a similar implementation, but, our .edu discount with MS cant be beat.
I would have to say that you must identify the system you will use for your company's SDLC first. The process template is merely a tool and without a good understanding of the underlying process it will not help and can make things more difficult. User adoption is crucial to the success of the SDLC and process template.
We use Scrum for Team System. We chose this due to our experience with Scrum as an SDLC methodology. There are several excellent books and articles on the web to help you get up to speed. Scrum will tie together the business stakeholders into the process.
In our system the Product Manager is in total charge of Product Backlog Items and works with myself and the CTO to prioritize them into Sprint Backlog Items.
The only change we have made to the process template was to add a "Failed Test" state and corresponding workflow.
It might not be the best template for you but I still wanted to mention it here: XP for Team System. It is basically a simplified version of MSF for Agile Software Development:
[...] it removes some of the setup tasks that an XP project will probably not want to undertake and changes the Work Item Type name Scenario to Story.
My company are imposing Jira and Zephyr on us for defect tracking and test management. We're quite happily using TFS 2008 for both these jobs at the moment, but management have never let the fact that something isn't broken stop them from trying to fix it.
Are there any tools/plug-ins that will allow us to synchronise between the remotely hosted repositories and our in-house TFS server?
Probably too late, but the company might want to look at the new features for bug tracking and manual tests coming in the 2010 release. Nice as Jira is, I doubt it will integrate well with the historical debugger and the ability to include a video of the test, as well as information on the test environment, and have it all be part of the work item.