Links Útiles 1–Team Foundation Server 2010

1.Sobreescribir la propiedad OutDir

http://blog.codeassassin.com/2012/02/03/override-the-tfs-team-build-outdir-property/

2.Copiar/Mover un Team Project Collection a otro server

http://msdn.microsoft.com/en-us/library/dd936138.aspx

http://www.bobhardister.com/archive/2012/01/23/copy-a-team-foundation-server-2010-collection-to-a-different.aspx

3.Ejecutando scripts de powershell en máquinas remotas

http://www.jrjlee.com/2012/02/running-powershell-scripts-on-remote.html

4.Integrando Team Foundation Server 2010 con Sharepoint

http://blogs.msdn.com/b/tfssetup/archive/2012/02/21/integrating-team-foundation-server-2010-with-sharepoint-2010.aspx

5.Setear el puerto SMTP de TFS 2010

Cuando configuras las setting de SMTP Settings para TFS 2010 y deseas especificar un puerto diferente para el server de smtp (defautl: 25).

http://msmvps.com/blogs/vstsblog/archive/2012/02/18/how-to-set-the-smtp-port-in-tfs-2010.aspx

TFS EXPRESS

Habrá una nueva herramienta con la salida de TFS 11, llamada Team Foundation Express.

Incluirá las características principales de desarrollo:

• Control de código fuente
• Seguimiento de work items
• automatización de builds
• agile taskboard

La edición Express es esencialmente lo mismo que TFS que se obtiene cuando se instala el TFS con el asistente básico, salvo que la instalación se recorta (trimming) . Además de las limitaciones básicas TFS normales de instalación (sin la integración de SharePoint, sin reporting ), TFS Express:

• Se limita a no más de 5  (5 Windows Ids diferentes en un grupo)
• Sólo es compatible con SQL Server Express Edition
• Sólo se puede instalar en un único servidor
• Incluye el dashboard de ágil, pero no las herramientas de planning.
• No incluye el proxy de TFS y los nuevos  Preemptive analytics add-on.

Usted puede agregar más usuarios con la simple compra de Licencias de acceso de cliente (CAL)para los usuarios adicionales. Y si quieres más de las características de TFS estándar, usted puede actualizar a una licencia TFS completa sin perder ningún dato.
También han permitido la integración de TFS con Visual Studio Express

Fuente:

http://blogs.msdn.com/b/bharry/archive/2012/02/23/coming-soon-tfs-express.aspx

TFS Reporting–Introducción

Hay pocas empresas que usan la funcionalidad de reportes de TFS. Les explicaré un poco el funcionamiento básico.

La base de datos de configuración de TFS (Tfs_Configuration) contiene toda la información necesaria para manetener TFS en marcha y funcionando.Contiene información sobre las distintas colecciones de proyectos, la seguridad del servidor, eventos, notificaciones, jobs, etc

La base de datos de configuración de TFS registra todos los Team Project Collections. La base de datos del Team Project Collection es el almacén operativo (Tfs_DefaultCollection). Todos los datos que se reúnen en todos los Team Project son escritos a esta base de datos. Elementos de trabajo, control de versiones, builds, Seguridad, etc

Todas las bases de datos de collectiones se consolidan en la base de datos de Warehouse (Tfs_Warehouse). No todos los datos en el almacén operativo se envía a esta base. Los works items que establezcan el atributo reportable (más información sobre los diferentes atributos que puedes encontrar aquí). Por ejemplo, si se agrega un campo a un elemento de trabajo usted puede elegir cómo el campo se publica en el almacén (ninguno, dimensión, medida o detalle). La mayoría de los campos que se agregan serán campos de dimensión (categoría, nombre del equipo, prioridad, etc).

El TFS warehouse es una base de datos relacional. Una vez cada dos horas (intervalo se puede cambiar véase http://msdn.microsoft.com/en-us/library/ms244694.aspx) el cubo de TFS (Tfs_Analysis) es actualizado con nueva información. Sólo dimensiones y medidas son enviados al cubo.

Algunos tips–Post 1

Saber la lista de archivos que se hicieron check in un día específico

Abrir una Visual Studio Command Prompt (2010) y usar el comando

tf history "local path" /version:D2011-03-29 /recursive /noprompt

Reemplaza la fecha con la que deseas y el “localpath” con la carpeta local que tiene mapeadas, obtendrás el changeset y todos los items que se cambiaron. Es posible usar una collección y un path remoto en vez del local.

Más info de TF HISTORY: http://msdn.microsoft.com/en-us/library/yxtbh4yh.aspx

 

Modificar el template de email de notificación de builds

Puedes encontrar los email templates en %PROGRAMFILES%\Microsoft Team Foundation Server 2010\Application Tier\TFSJobAgent\Transforms y modificarlos todo lo que quieras. en este folder encontrarás los eventos de build completion en formato xsl.

Cada evento tiene un template en el TeamFoundation.xsl stylesheet.

Build Completion Event

Build Status Changed Event

Más info: http://www.dotnetcurry.com/ShowArticle.aspx?ID=330

http://qa.social.msdn.microsoft.com/Forums/eu/tfsgeneral/thread/05586cb7-10b4-4a07-823e-2555e74d91b6

http://msdn.microsoft.com/en-us/library/bb552337.aspx

Opción “Clean Workspace” a la hora del build

En la opción Clean Workspace de la definición de build, podrá seleccionar las siguientes opciones:

- All           - borrar todo en la máquina de build

- Outputs   - borrará todos los binarios y descargará sólo los archivos modificados desde el Source Control

- None       - dejará todo inclucyendo los binarios del build anterior y descargará los archivos modificados desde el Source Control

Source Server and Symbol Server Support in TFS 2010

What are Symbols?

John Robbins has an excellent blog post to get started about learning what symbols are titled: “PDB Files: What Every Developer Must Know.” I highly recommend you take a moment to read through it.

So to summarize from John’s article, the symbol files are the .PDB files that match a particular assembly and contain important information that’s necessary for debugging tools. Specifically for .NET assemblies, the symbol files include:

• Source File Names and Line Numbers
• Local Variable Names

He also reminds us one very important statement about symbol files: “PDB files are as important as source code!” That is absolutely true! I cringe any time I hear from a developer that says “oh, those .PDB files take up so much space so I’m going to delete them.” Ouch – The sad thing is those are developers that keep people like John in business whenever they run into problems in production. Save yourself some time, money, and effort and keep your symbol files around. Not to say that John doesn’t earn every penny but I’m sure his life is much better whenever you do have your symbols!

This is exactly where Symbol Server helps out. Essentially, the Symbol Server is a central location for your company that keeps the .PDB files for you. Therefore, you can install your application (without symbols) that was compiled from a build server and whenever you want to use a debugging tool like Visual Studio, it will know how to contact the Symbol Server location to get the matching set of symbols. More about how to configure Visual Studio to look for a Symbol Server further down in this blog post.

John also mentions how to manually perform the steps necessary for completing the loop with Source Server and Symbol Server. Thankfully, since you are using TFS 2010 Build, you don’t have to go through those steps. The functionality is included in the default build build process template (but not the Upgrade Template).

Conectar Visual Studio 2008 con Team Foundation Server 2010

Primero que nada verifica si Visual Studio 2008 tiene el complemento de control de código fuente:Herramientas/Opciones/Control de Código Fuente

Complemento de control de código fuente

Si no aparece “Visual Studio Team Foundation Server”, primero necesitamos descargar Visual Studio Team System 2008 Team Explorer

Después, necesitamos descargar la Actualización de compatibilidad con versiones posteriores de Visual Studio Team System 2008 Service Pack 1 para Team Foundation Server 2010. El proceso es el mismo, dar clics en el boton de “Siguiente” y aceptar la licencia:

Reporting Services error: Cannot impersonate user for data source 'TfsReportDS' (rsErrorImpersonatingUser)

Getting this error (and your TFS is installed on a Domain Controller)?

Problem:

An error has occurred during report processing. (rsProcessingAborted)
Cannot impersonate user for data source 'TfsReportDS'. (rsErrorImpersonatingUser)
Logon failed. (rsLogonFailed)
Logon failure: the user has not been granted the requested logon type at this computer. (Exception from HRESULT: 0x80070569)

Solution:

Make sure that the local policy of the DC allows for login of non-admin users.

(Domain Controller Security Policy > Local Policies | User Rights Assignment | "Allow log on locally" policy and add domain users.

Fuente:

http://msmvps.com/blogs/vstsblog/archive/2010/08/16/solved-reporting-services-error-cannot-impersonate-user-for-data-source-tfsreportds-rserrorimpersonatinguser.aspx

TFS 2010 : How to apply check-in policies to only certain branches or folders

First install the TFS 2010 Power Tools by downloading it to your Client box. You can do a bing search to locate the “TFS 2010 Power Tools download”. This has to be installed on each Client box on which Visual Studio 2010 is installed.

Then go to Source Control as shown below:

Using Team Foundation Server 2010 Source Control from SQL Server Management Studio

 

While Team Foundation Server 2010 may be primarily known for handling applications, there are extended abilities that will allow you to store other types of mission critical information which is what we’ll be taking a look at.

As with most data-driven applications, the code is something that we safeguard fairly well but sometimes the queries and other database objects are overlooked. I hate speaking from personal experience but how many times have there been attempts to “fix” a stored procedure that ends with disastrous results?

One neat feature that we’ve been exploring is storing queries that we work on into Team Foundation Server 2010 and I’ll be sharing that information with you.

There are some prerequisites involved. Make sure that you have the following available and installed:

•    SQL Server Management Studio 2005, 2008 or 2008 R2 (Express versions will not work)
•    Team Foundation Server MSSCCI Provider 2010
•    Added your user to the collection
•    Have an existing Team Project or have created a new Team Project
•    Have proper permissions to the project

I’ll be concentrating on getting new SQL scripts through a SQL Server Management Studio project to your Team Foundation Server.

Using TFS2010 with Visual Studio / BIDS 2008 and SQL Server Management Studio

 

Installing the TFS 2010 tools for Visual Studio / BIDS 2008

First off, thanks to Derek Miller for covering most of the steps involved in his blog posthttp://derekjmiller62.wordpress.com/2010/10/19/using-tfs-2010-with-bids-2008/. I won?t go into the detail he did, but will summarize into these basic steps.

1. If you haven?t installed Visual Studio 2008 Service Pack 1, do so by downloading it and installing.

2. Next, you will need to install the Visual Studio 2008 Team Explorer.

3. After installing Team Explorer, you will have to go back and reinstall VS SP1 (from step 1). Don?t skip this step!Team explorer has some older components that overwrite the SP1 components, and you will have reinstall them.

Now this next part I really haven?t seen anywhere else and was a real pain to find, and thus is the main reason for this post. During the SP1 install, we often see ?Visual Studio SP1 Installation Failed?. Checking the error log, buried deep you will find ?Returning IDOK. INSTALLMESSAGE_ERROR [Error 2902. An internal error has occurred. . . .?

When you see this, go to your Control Panel, and then to Add Remove Programs. Look for a program called ?Microsoft Visual Studio Web Authoring Component? and uninstall it. This is actually installed as part of the Office suite, and you don?t really need it since you likely have much more powerful web authoring tools, or since you are doing BI development won?t be doing an web development in Microsoft Office.

After uninstalling it, SP1 should then install, and you are ready for step 4.

4. Install the Visual Studio Team System 2008 SP1 Forward Compatibility Update for Team Foundation Server 2010. That probably took you longer to read than it actually will to install. After installing, it may prompt you to reboot. Even if it doesn?t ask you should reboot anyway, we?ve seen a few times when we weren?t able to connect until we rebooted.

After that you should be able to go into Visual Studio and go to Tools, Connect to Team Foundation Server. If you still have problems connecting, I will refer you to Derek?s post where he describes some registry entries you can try. So far we haven?t found them necessary, but you may.

Borrar Team Project Collection

1. On your TFS server, open an Administrative Command Prompt
2. Change into the TFS Tools Directory. Type:
   cd "%programfiles%\microsoft team foundation server 2010\tools"
3. Type in the following (replacing [COLLECTION NAME] with the collection you want to delete):
   TFSConfig Collection /delete /collectionName:[COLLECTION NAME]

If you created a SharePoint Portal for your Team Project Collection, you should clean it up as well.

1. Open the URL of your Team Project Collections SharePoint portal (eg. http://northwind.com.au/tfs/TestProjectCollection)
2. Select Site Actions | Site Settings on the right
3. Under the Site Administration subheading, click on Delete this site
4. Confirm the deletion

If you created a Reports site for your Team Project Collection, you should clean it up as well.

1. Open the URL of your Reporting Services page (eg. http://tfs.ssw.com.au/Reports/)
2. Click on the TfsReports folder
3. Click on the name of the Team Project Collections folder
4. Click Properties in the top navigation
5. Click on Delete

Now your TFS server is nice and clean and fit for production.

Where to store my documents in TFS

Let me start with listing the different possibilities:

• Store your documents as an attachment of a Work Item
• Store your documents on the SharePoint portal (or documents folder in Team Explorer)
• Store your documents in Source Control

Store your documents as an attachment of a Work Item

You can store attachments in work item. This is convenient because you have all the extra information (such as screen dumps, xml schemas, diagrams etc.) together with the bug or task.

On the other hand it is more difficult to find attachments.

Conclusion:

Store attachments in a work item if the file is only related to the work item and not to other work items or requirements.

A screen dump of an error is a good example of an attachment, but a diagram for some functional design can better be stored somewhere else.

OData Service for Team Foundation Server 2010

The purpose of this project is to help developers work with data from Team Foundation Server on multiple device types (such as smartphones and tablets) and operating systems. OData provides a great solution for this goal, and has been embraced by numerous developers for building great device-specific applications. OData is accessible from any device and application stack which supports HTTP requests. This OData service interacts directly with the TFS client object model.

What is OData?
OData exposes a way to work with data over the web. If you’re new to OData, I suggest spending a few minutes at http://www.odata.org/ reading about this evolving standard. It uses interfaces similar to REST, so that you can programmatically consume and manipulate data from any device or application stack which supports HTTP requests.

Team Foundation Server was an obvious choice since it not only allows developers to extend TFS in new and interesting ways, but it also allows us to further showcase support for this evolving standard with the developer community at large.

 

Más información:

http://blogs.msdn.com/b/briankel/archive/2011/10/26/odata-service-for-team-foundation-server-2010-v1.aspx

Cambiar el tamaño de los attachments

There where people who changes the attachment size using code:

TeamFoundationServer tfs = TeamFoundationServerFactory.GetServer(@"yourtfsserver/.../DefaultCollection");
ITeamFoundationRegistry rw = tfs.GetService<ITeamFoundationRegistry>(); 
RegistryEntryCollection rc = rw.ReadEntries(@"/Service/WorkItemTracking/Settings/MaxAttachmentSize");
RegistryEntry re = new RegistryEntry(@"/Service/WorkItemTracking/Settings/MaxAttachmentSize", "20971520");//20MB
        
if (rc.Count != 0)
{    
    re = rc.First();    
    re.Value = "20971520";
}
        
rw.WriteEntries(new List<RegistryEntry>() { re });

But the only thing you had to do in order to change the attachment size in TFS 2010 is to change_tfs_resources to the collection name, as follow:

http://localhost:8080/tfs/_tfs_resources/WorkItemTracking/v1.0/ConfigurationSettingsService.asmx?op=SetMaxAttachmentSize 

TO:

http://localhost:8080/tfs/<CollectionName>/WorkItemTracking/v1.0/ConfigurationSettingsService.asmx?op=SetMaxAttachmentSize

Descargar automáticamente la última versión al editar un archivo

Para el primer caso, debemos acceder a las opciones de Visual Studio 2010, desde el menú “Tools // Options”. Dentro de las mismas acceder a la sección “Source Control // Visual Studio Team Foundation Server” y marcar o desmarcar la opción “Get latest versión of ítem on check out in server workspace”. Esta opción nos asegura que siempre tengamos la última versión de cualquier archivo que estemos editando.

Ahora bien, si lo que queremos es que esta forma de trabajo se aplique para todos los integrantes de un Team Project, podemos aplicar esta configuración a nivel de TP. Para esto, desde en panel Team Explorer, seleccionamos el Team Project correspondiente, luego desplegamos el menú contextual y seleccionamos “Source Ccontrol”. Dentro de la sección “Chec-out settings”, la opción “Enable get latest on check-out” nos permite definir este funcionamiento.

Fuente:

http://geeks.ms/blogs/elbruno/archive/2012/02/12/tfs2010-howto-configurar-la-descarga-automatica-de-la-ultima-version-desde-el-ide-o-desde-tfs.aspx

 

Compilar VB6 con TFS 2010

 

Note: There are alternative ways to build VB6 applications not using this activity that are documented in other blog posts

• With the InvokeProcess activity
• Using a MSBuild Task

Before you can make use of any of the TFS 2010 community build activities you have to make sure they are available for the build system and on your development PC. Instructions for this process can be found in the ALM Rangers build guide or in the StyleCop page of this wiki. This page assumes the VB6 activity is available in the developers build process workflow toolbox.

 

Installing VB6

As this activity is a wrapper for the VB6 command line tool, VB6 must be installed on all TFS Build Agent PCs that could run the workflow.

Add the activity to the workflow

The VB6 activity should added to the workflow.  Assuming you are modifying the default build process template, then the key is to replace the MSBuild activity in the ‘Compile the Project’ sequence, as shown below.

Team Foundation Server 2010: Enable checkin policy through code

1. var projectCollectionUri = new Uri("http://tfs2010:8080/tfs/MyCollection");  
2. var projectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(projectCollectionUri, new UICredentialsProvider())  
3. projectCollection.EnsureAuthenticated();  
5. var vcs = projectCollection.GetService<VersionControlServer>();   
7. var teamProject = vcs.GetTeamProject("SomeTeamProject");  
8. var workItemPolicy=new WorkItemPolicy();  
10. foreach (PolicyType policyType in Workstation.Current.InstalledPolicyTypes)  
11. {  
12. if (policyType.Name == workItemPolicy.Type)  
13.     {  
14.         teamProject.SetCheckinPolicies(new PolicyEnvelope[] { new PolicyEnvelope(workItemPolicy, policyType) });  
15. break;  
16.     }  
17. } 

 

Fuente:

http://bartwullems.blogspot.com/2012/02/team-foundation-server-2010-enable.html#

TFS Membership Visualizer

TFS Membership Visualizer allow you to generate a dependency graph of TFS security groups and membership

TFSSCExplorerExtension

FSSCExplorerExtension (Team Foundation Server Source Control Explorer VS 2010 Extension) is Visual Studio 2010 Extension Package that adds new features to the TFS Source Control Explorer window for TFS 2010. Most important new features are Drag & Drop support, Move and Branch functions even for multiple files selection and Merge from Sources feature.

I also released separate version for Visual Studio 11 Developer Preview here.

Java SDK for TFS

You will be able to extend TFS using Java just as easily as you can with .NET.  This is going to enable teams using Team Explorer Everywhere to fully customize their development environment – in Eclipse or outside.

The TFS SDK for Java includes the following:

• A redistributable JAR file containing the TFS API’s.  This is a the same Java code that is used by Team Explorer Everywhere in the TFS plug-in for Eclipse and the Cross-platform command line client.  It provides access to version control, work item tracking, build and other functionality in TFS from your own Java based application.   We ship this as a single JAR file containing all the code and Java dependencies to make is easy to include in your own applications.
• The native code libraries used by the TFS API. We have a small amount of JNI code in the API to handle functionality that is not natively supported in Java on all the platforms that we support (such as access to Kerberos for authentication, or integrating with Keychain on the Mac).  We are making this native code available, also redistributable and compiled for Windows (x86, x64), Mac (Universal), Linux(x86, x64, ppc), HP-UX (ia64_32, pa_risc), Solaris(sparc, x86, x64) and AIX (ppc).
• Full API documentation in Javadoc format.  This is the same code documentation used by our developers, written by our developers.
• Code Samples. The team are very aware that getting started with this large code base can be quite a challenge, therefore they have put together a bunch of sample code to try and get you started.  It includes: 
  • Sample custom check-in policy
  • Sample custom work item controls (including a Radio Button control, Simple Button control, File Source drop-down and a sample External Source drop-down)
  • A set of sample console applications utilizing build and version control capabilities
  • A series of simple snippets demonstrating many aspects of the API including Work Items, Version Control and Build access.
  • Instructions for building and an Ant based build script to get you started.

Why upgrade from Visual Source Safe (VSS) to TFS 2010?

recommendation to upgrade your SCM from Visual Source Safe (VSS) to using TFS and here are the 8 reasons for that.

1. Set of Services:

While VSS offers only version control service, there are many integrated services offered by TFS. Services offered by TFS include Work Item Tracking service, Build service and Source / Version control service as foundation services. These services generate data. Based upon these foundation services, are the dependent services, which consume the data generated by foundation services. Those dependent services are reporting service and team portal service.

Reporting service analyzes the data generated by foundation services and provides reports based upon those. Visibility to those reports as well as other collaboration features are provided by team portal, that is based upon the SharePoint technology. TFS is not only a source control mechanism but a complete set of Application Lifecycle Management (ALM) services.

All these services are integrated by design, so you get additional benefits. For example while you are checking in code which is part of source control service, you can associate a work item like a task or a bug that you have fixed in that code. This association will provide excellent traceability between the work that is assigned to the team member and the actual code that team member has created against that work. This traceability is both ways. We can safely say that the services provided by VSS are only 20% or less compared to those provided by TFS.

Algunas características de TFS 2010

 

• Folder versioning. Rapid refactoring often involves changing not just the code but also it’s structure. TFS Folder versioning supports this.
• Branching. Within an iteration/sprint each individual/pair/feature crew might want their own branch or branches in order to support parallel development across the team. TFS branching helps to support this and, importantly, to track what’s happening with branch visualisation and timeline tracking. Branches are now first class citizens in TFS 2010 and as such have fine grained permissions and capabilities.
• Shelving. This TFS feature allows a developer to “park” code in a sand boxed area on the TFS server such that it is safe, but won’t effect anyone else’s code or any builds. This can help with safely sharing code, including code reviews.
• Annotation. In a rapidly changing codebase annotation allows you to overlay who did what and when into the source code itself. This can help quickly identify exactly what lines of code were changed, by who, and for what reason, in a specific build.
• Check-In Policies. Rapid code changes and check-ins shouldn’t mean that code quality suffers. TFS check-in policies allow you to define a quality gate to ensure that all code reaches a certain quality before it reaches the repository. For example, specific unit tests have been run and passed and code has been associated with one or more user stories or tasks.
• Change Sets. Maintaining the context of a check-in becomes even more important with rapid, frequent check-ins. Why did that code get checked in? A change set identifies which files were checked in and what user stories or tasks were associated with the check-in. To be able to go back and understand why changes were made (e.g. these files were checked in to fix bug 23) can save considerable time and effort at a later point in the project.
• TFS Proxy Server. Allows a remote team to get versions of the code and checkout from a local cache, rather than having to traverse a WAN to the central TFS server.

TFS 2010 – Application Tier Version Control Cache Configuration details

The following applies to the AT cache only (the real proxy is close but not identical as it does not have access to the TFS registry)

The TFS registry is the first place we look for settings:

• /Service/VersionControl/Settings/FixedSizeBasedPolicy indicates a fixed size cache (in MB)
• /Service/VersionControl/Settings/CacheLimitPercent is the alternative (i.e. % of the available disk space occupied rather than fixed size)
• /Service/VersionControl/Settings/CacheDeletionPercent is how much of the cache should be deleted when the threshold is reached (think of it as hysteresis)
• /Service/VersionControl/Settings/StatisticsPersistTime is how often the statistics file is saved to disk (not so interesting)
• /Configuration/Application/DataDirectory indicates where the AT cache will live

We then validate those settings (or come up with default if not found).

1. If nothing is set, the default is CacheLimitPercent = 75%
2. If both CacheLimitPercent and FixedSizeBasedPolicy are set, FixedSizeBasedPolicy wins.
3. If CacheDeletionPercent is not set, it defaults to 20%
4. StatisticsPersistTime defaults to one hour (any value above one hour is acceptable).
5. DataDirectory can be overridden by adding a node in the web.config file like so (in which case it overrides the /Configuration/Application/DataDirectory setting):

<appSettings>

<add key="applicationDatabase" value="Data Source=dbserverhere;Initial Catalog=Tfs_Configuration;Integrated Security=True;" />

<add key="WorkItemTrackingCacheRoot" value="C:\Windows\Temp\TFTemp" />

<add key="traceWriter" value="false" />

<add key="traceDirectoryName" value="%TEMP%\\TFLogFiles" />

<add key="applicationId" value="GUID here" />

<add key="dataDirectory" value="E:\" />

</appSettings>

Important considerations:

• ·In an NLB environment, the TFS registry settings apply to ALL nodes, which is why the web.config settings take priority.
• CacheLimitPercent is a bit misleading in that if you have a 100GB drive and 50GB of other content, the TFS Cache can only use 50GB, so by default, the cleanup will occur when the cache reaches: (CurrentCacheSize + AvailableSpace) * (CacheLimitPercent / 100) = 50GB * .75 = 37.5 GB
• The Cache Cleanup can take a long time (hours on a very large drive) – so I would recommend changing the default Idle Time out on the Application pool to at least 60 minutes if you have a large cache and infrequent requests.

Fuente:http://blogs.msdn.com/b/girishp/archive/2012/01/21/tfs-2010-application-tier-version-control-cache-configuration-details.aspx

Build SharePoint Projects with TFS Team Build

Introduction

Microsoft Visual Studio 2010 provides a brand new set of tools for developing SharePoint applications. With these tools, developers can easily leverage the familiar Visual Studio environment and functionality to develop, package, deploy, and debug custom SharePoint solutions. Team development is also well-supported by these tools. You can check your SharePoint projects into Team Foundation Server (TFS) source control and build and package your projects in TFS Team Build. This article describes how to build SharePoint projects developed by the VS2010 using Team Build when neither Visual Studio 2010 nor SharePoint 2010 is installed on your build system. If Visual Studio 2010 or/and SharePoint 2010 are installed on the system, however, you can skip some of the steps below that patch the system with necessary dependencies.

1.  Prepare the Build System

To build and package SharePoint projects, several components must be installed on your system.

• Install TFS Team Build
  If your build system already has TFS Team Build installed on it, you can skip this step. Otherwise, install and configure Team Build on your build system. Both Team Build 2008 and Team Build 2010 can build and package SharePoint projects created in Visual Studio 2010.
• Install .NET Framework 4
  If you are using TFS Team Build 2008, you must install .NET Framework 4 because it is not installed by default. You can download .NET Framework 4 here:http://msdn.microsoft.com/en-us/netframework/default.aspx. After installing .NET Framework 4, update the build path of TFS to point to the location of .NET Framework 4 by doing the following:
• 1. On the Build system, navigate to: \Microsoft Visual Studio 9.0\common7\IDE\PrivateAssemblies;
  2. Open the TFSBuildService.exe.config file using Notepad running as Administrator.
  3. In the file, find the MSBuildPath setting in the AppSetting section.
  4. Set the path value to the location of.NET Framework 4. (For example, C:\Windows\Microsoft.NET\Framework\v4.0.21116);
  5. In the Windows Services console, restart the Visual Studio Team Foundation Build Service.

Creating a backup in Team Foundation Server 2010