The Team Foundation Server (commonly abbreviated TFS ) is a Microsoft product that provides source code management (either Foundation Foundation or Git Team Version Control), reporting, requirements management, project management for agile software development and waterfall team), automated manufacture, laboratory management, testing and release management capabilities. It covers the entire application life cycle, and enables DevOps capabilities. TFS can be used as a back-end for various integrated development environments (IDE) but tailored for Microsoft Visual Studio and Eclipse on all platforms.
Video Team Foundation Server
On-site vs. online
Team Foundation Server is available in two different forms: local and online. The last form is called Visual Studio Team Services (formerly Visual Studio Online). The cloud service is supported by Microsoft's cloud platform, Microsoft Azure. It uses the same code as the on-premises TFS version, minor modifications, and implements the latest features. The Visual Studio Team service requires no setup. A logged-in user uses a Microsoft account to organize the environment, create projects, and add team members. New features developed in the short development cycle are added to the cloud version first. These features migrate to the local version as an update, about three months interval.
Maps Team Foundation Server
Architecture
Server Architecture
Team Foundation Server is built on a multi-tier, scalable architecture. The main structure consists of an application layer that is responsible for processing logic and maintaining web application portals (referred to as Web Access Team or TWA). TFS is built using the Windows Communication Foundation web service. This can be consumed by any client, although the client object model is recommended. Tier data and application tier can exist on the same machine.
To support scalability, the application level can be a balanced load and data levels can be grouped. If using Microsoft SQL Server 2012, the AlwaysOn SQL Server Failover Cluster and Availability Group are supported that allow for geographic data replication. The main container is a collection of projects. Project collection is a database containing a group of Project Teams. Project Collections is another scalability mechanism, in which each collection can be placed on various SQL Servers or SQL Server instances. The 'Oe' configuration database per TFS instance stores the project collection metadata. Data from the project collection database is collected into the warehouse database, which normalizes the data in preparation for loading into the Analysis Services cube. Warehouses and cubes enable trending reporting and complex data analysis.
TFS can integrate with existing SharePoint fields. The SQL Server Reporting Service is supported for more advanced reporting of data warehouse or Data Analysis Services cube. This installation can be on the same system or on different systems. Build server, laboratory management server, release management server and proxy server (to reduce some load at the application level), test machine and load test machine can also be added to the infrastructure. To support teams that require enterprise project scheduling, TFS is also integrated with Microsoft Project Server, enabling enterprise-level portfolio management, resource management and project tracking.
Extensibility
Microsoft provides two APIs that are distributed separately to connect to TFS. One is the Java SDK, the other is the.NET Framework SDK. This API enables client connectivity to TFS. Because TFS is written on service-oriented architecture, TFS can communicate with almost any tool that can call web services. Another extensible mechanism is to subscribe to system alerts: for example, notices that work items are modified, or completed. There are about 20 preconfigured alerts, and the team can configure as many additional warnings as needed. When used in expandable scenarios, these alerts can be sent to web services, triggering actions to modify or update work items (such as applying advanced business rules or creating work items based on a given scenario based program).
The data warehouse can also be expanded through the creation of custom data warehouse adapters. With the introduction of TFS 2012, custom add-ins can also be created for Team Web Access, called Web Access Extensions .
Client
TFS supports Visual Studio 2010 and later, Microsoft Test Manager (MTM) 2012 and 2013. Eclipse, older Visual Studio versions, and other environments can be plugged into TFS using Microsoft Source Code Control Integration Provider (pronounced "Miss- Key "). These tools provide full access to features in TFS.
Microsoft Excel and Microsoft Project are also supported to help manage work items that allow for bulk updates, bulk entries and bulk export of work items. Microsoft Project can be used to schedule work when adjusting to the waterfall software development methodology. Both Excel and Project support two-way data updates. This allows, for example, the project manager to place a schedule on the Project, has a job imported into TFS where the developers update the work and then the schedule can be updated without the project manager having to do additional work.
With Team Foundation Server 2012, Microsoft PowerPoint also integrates with TFS to enable rapid storyboard development to aid the requirements management process. This integration provides an expandable storyboard form that can be used to build all types of mockup interfaces that can then be animated with PowerPoint built-in functions. The storyboard can then be linked to work items.
In an effort to deal with geographic deployment of teams and to engage early and more frequent stakeholders in the process, Microsoft added Input Clients. This tool allows users to run applications, annotate what they see with audio and video, capture the screen and provide contextual feedback to the development team. It provides special feedback on application functionality from a user perspective without requiring meetings and demonstration sessions. TFS also provides command line tools for Unix and Windows environments. Power Tools for TFS include a Windows shell integration that allows users to check incoming and outgoing files, add files and perform other basic tasks by right-clicking on a file or folder.
Work item
At the heart of TFS is "work item". Work items represent something - this can be a work to be done, risk to track, test case, bug or anything imaginable by the user. Work items are defined through an XML document and are highly expandable. Work items are combined into Process Templates that contain these and other pieces of information to provide the development framework. TFS includes Process Templates for Microsoft's Solutions Framework for Agile, Scrum and CMMI. Teams may choose to use built-in templates or one of the many templates available for use created by third parties. Process templates can be customized using the Process Template Editor, which is part of Power Tools.
Work items can be linked to each other using different relationships to create a hierarchical tree of work items or a flat relationship between work items. Work items can also be linked to external artefacts such as web pages, documents on sharing files or documents stored in other repositories such as SharePoint. Work items can also be linked to source code, generate results, test results and specific versions of items in source control. Flexibility in work item systems allows TFS to play many roles from requirements management to bug tracking, risk and problem tracking, as well as record review results. Extended linking capabilities ensure that traceability from requirements to source code to test cases and results can be completed and reported for auditing purposes and a historical understanding of change.
Source control
Team Foundation Server supports two different types of source controls - the original source control engine called Team Foundation Version Control (TFVC) and with the release of TFS 2013, it supports Git as the core source control repository.
Team Foundation Control
TFVC is a centralized version control system that allows teams to store all types of artifacts inside the repository. TFVC supports two different types of workspaces when working with client tools - Server Workspace and Local Workspace. The server workspace allows developers to lock files for check-out and notify other developers that the file is being edited. A common complaint for this model is that the files on the development engine are marked as read-only. This also requires developers to "offline" when the server can not be contacted. Local workspace is designed to avoid this problem. In the local workspace scenario file is not read-only and they should not be checked before doing it. As long as the file resides in the developer's local machine, it does not matter if the server is connected or not. Conflict is handled upon check-in.
To improve performance for remote clients, TFS includes the ability to install Proxy Servers. Proxy servers allow source control content to be cached on sites that are closer to the developer to avoid long network travel and related latency. Check-in is still done directly against TFS application tiers so Proxy Server is most useful in reading scenarios.
As part of the source control engine, TFS supports a number of features to help developers ensure code is checked following configurable rules. This rule engine is called the Check-in Policy. There are some off-the-box policies like the Change Comments Policy which does not allow check-ins unless the developers enter check-in comments. This policy can be expanded and can be used to check all aspects of the code being checked, comments and work related items. TFS also supports Code Analysis feature which when used independently is known as FxCop. Inclusion in TFS means that the analysis can be executed against the code that is checked into the server and during automatic creation.
Git
With the launch of TFS 2013, Microsoft added native support for Git. This is not a specific implementation of Microsoft but a standard implementation based on the libgit2 library. This is the same library that empowers the popular GitHub and code is available for free from GitHub. Because Microsoft takes an approach using standard libraries, every Git client can now be used natively with TFS (in other words, developers can use their favorite tools and never install standard TFS clients). It allows tools on all platforms and any IDEs that support Git to connect to TFS. For example, Xcode and Android Studio support Git plug-ins. Additionally, if developers do not want to use Microsoft Explorer's Team Explorer Everywhere plugin for Eclipse, they can choose to use eGit to connect to TFS.
Using Git does not preclude the use of TFS work items or build systems. When checking the code with Git, referring the work item ID in the check-in comment will associate the check-in with the given job item. Likewise, Team Build will also build the Git project.
One of the main reasons for using TFS as a Git repository is that it is supported by SQL Server and is given the same protection as the Foundation Team Version Control. This gives developers some choice when choosing the type of project and work style that works best for them.
At this point the source code can not be moved from the TFVC repository to the Git repository. However, by using the Git-TF tool, the Git repo can be moved to the TFVC repository.
Reporting
Reporting has been a core component of TFS since its initial release in 2005. The reporting infrastructure consists of a data warehouse (Tfs_Warehouse) which is a relational database and SQL Server Analysis Services cube data. Both of these sources are available for reporting through the SQL Server Reporting Service when this option is installed. Since this is a standard database and cube structure, any tool that can point to this data source can report from it. This includes tools such as Cognos, Tableau, Excel, and other reporting tools. Included with each template out of the box is a series of reports for reporting services that include Build information, test results and progress, project management, agile reports (Backlog Overview, Burning Release, Sprint Burning and Speed), bugs and issue data. New reports can be created using Report Builder for SSRS and any of the existing reports can be modified.
More specific reporting is available for load test results. This data is available directly within Visual Studio and can be exported to Excel for detailed analysis.
TFS 2013 introduces a new feature called "light reporting" that provides the ability to create real-time reports based on query results and which do not rely on warehouses or cubes. TFS 2012 (and continues to 2013) offers real-time burndown, speed and CFD diagrams directly in the Web Access Team.
Team Build
Team Build (before TFS 2015) is a server build application that is included with Team Foundation Server. The two components form Team Build - MSBuild and Windows Workflow Foundation. MSBuild is a declarative XML language similar to Apache Ant. WF is added to the development process starting with TFS 2010; before that only MSBuild is available. The ability to build continues to grow with every subsequent TFS release. In TFS 2010 and 2012, the WF template file (Extensible Application Markup Language) is stored in source control and can be edited and inverted directly from the source control. In TFS 2013, these files are removed to remove clutter and streamline the creation process. The WF template can still be downloaded, edited and stored in source control if desired and TFS 2013 does not damage the existing TFS 2010 or 2012 Template creation process. With Git support in TFS 2013, Team Build has been upgraded to allow for automatic development of Git projects as well as TFVC projects.
Windows Workflow controls the overall flow of the creation process and TFS includes many pre-generated workflow activities to manage common tasks performed during the creation. MSBuild is a markup language found in the.proj files (csproj for C # and vbproj projects for Visual Basic projects). The build system can be expanded with users able to create their own workflow activities, the ability to inject MSBuild into the process and to execute external processes. The nature of the workflow of the building allows unlimited flexibility, but it may take some work to achieve that flexibility. Open source and sharing projects have begun to build community-supported activities to enhance the capabilities of Team Build.
The build process can be configured for various build types including scheduled builds, ongoing integration, check-in and gated rolling builds. A built-in gated check-in will override the code inspected by the developer, do a "get latest" on the server code and build. If the build is successful, the code is checked on behalf of the developer who sent the code. If the build fails, the developer will be notified and can fix the code before attempting another check-in.
Build has a storage policy with them so they do not accumulate when it is not needed (or build can be directed to not generate stored output) or build outputs can be locked and stored forever. New to TFS 2013 is the ability to check build results into source control. This is a necessary upgrade to support an automated build on the TFS service where there is no drop location to place the build. In the local build version version can be configured to end up in a shared folder location that can be accessed.
The build process in TFS is also part of the Traceability mechanism in the Build Team that brings together many artifacts created and stored in TFS. Assuming the developer associates the source code with work items at check-in, Team Build has the ability to report changes at each creation - both source code changes and work item changes as well as test results (this includes unit test results as well as automated functional test results (CodedUI )). Because bugs and PBIs are completed and integrated into the build, work items that track these artifacts are automatically updated to show where their builds are successfully integrated. Combined with testing tools, testers then get an integrated view of what code is modified in each build, but also bugs, PBIs and other jobs that are changed from build to build.
In Team Foundation Server 2015 and with Visual Studio Team Services, Microsoft has re-created the architecture for build engines based on a friendly cross platform-friendly Node.js application. The build agent of Windows, Mac, and Linux is currently supported. Visual Studio Team Services provides elastic build ability through building hosting in Microsoft Azure.
Release management
In mid-2013 Microsoft purchased a product called InRelease from InCycle Software. InRelease is fully incorporated into Team Foundation Server 2013. This capability complements the automated creation and testing process by enabling real-time deployment solutions. These tools are labeled "Management Release" for TFS 2013. The Release Management capabilities provide the ability for teams to perform controlled workflows, workflows (provided by Windows Workflow Foundation) that are driven into development, test and production environments and provide dashboards to monitor progress of one or more releases.
Microsoft has rebuilt Release Management for Visual Studio Team Services and local versions of Team Foundation Server with new changes in Update 2015. The new version of Release Management exploits the web browser as a client and relies on the same agency architecture as the Build Foundation Team. Release Management enables DevOps capabilities for Team Foundation Server.
History
The first version of Team Foundation Server was released in 2005.
See also
- Comparison of version control software
- Comparison of problem tracking system
- Microsoft Visual SourceSafe (VSS)
- List of version control software
- Rational Team Concert
- SVNBridge, a Windows client or a server-side extension for TFS that allows access to revised TFS controlled items from a Subversion client application.
- WinOps
References
External links
- Official website
- Team Foundation Server: In Work
- Visual Studio 2005 Team System: Enterprise Class Resource Control
- Using Source Code Controls in the Team Foundation
- Foundation Foundation Server Basics: A Look at the Capabilities and Architecture
- Visual Studio Team System 2008 Web Access
- Visual Studio Application Cycle Management
- Visual Studio Team Services
- Java support in Team Foundation Server and Visual Studio Team Services
- Server 2017 Team Release Notes
Source of the article : Wikipedia
0 Comments