You are viewing the documentation of TeamCity 9.x, which is not the most recently released version of TeamCity.
View this page in TeamCity 10.x documentation or refer to the listing to choose the documentation corresponding to your TeamCity version.

Skip to end of metadata
Go to start of metadata

TeamCity Data Directory is the directory on the file system used by TeamCity server to store configuration settings, build results and current operation files. The directory is the primary storage for all the configuration settings and holds the data critical to the TeamCity installation.

The build history, users and their data and some other data are stored in the database. See notes on backup for the description of the data stored in the directory and the database.

Note that in this documentation and other TeamCity materials the directory is often referred to as .BuildServer. If you have a different name for it, replace ".BuildServer" with the actual name.

On this page:

Location of the TeamCity Data Directory

The currently used data directory location can be seen on the Administration | Global Settings page for a running TeamCity server instance. Clicking the Browse link opens the Administration | Global Settings | Browse Data Directory tab allowing the user to upload new/modify the existing files in the directory.

The current data directory location is also available in the logs/teamcity-server.log file (look for "TeamCity data directory:" line on the server startup).

If you are upgrading, please note that prior to TeamCity 7.1 the data directory might have been specified in a different way.

Configuring the Location

Since TeamCity 9.1 the location of the directory can be set on the first server startup screens (only when TeamCity .tar.gz or .exe distribution is used). The specified data directory is then saved into <TeamCity home directory>/conf/teamcity-startup.properties file.

The location of the directory can be set manually using TEAMCITY_DATA_PATH environment variable. The variable can be either system-wide or defined for the user under whom TeamCity server is started. After setting/changing the variable, you might need to restart the computer for the changes to take effect.

If the TEAMCITY_DATA_PATH environment variable is not set and <TeamCity home directory>/conf/teamcity-startup.properties file does not define it either, the TeamCity Data Directory is assumed to be located in the user's home directory (e.g. it is $HOME/.BuildServer under Linux and %USERPROFILE%\.BuildServer under Windows).

Before TeamCity 9.1, the TeamCity Windows installer configured the TeamCity data directory during installation by setting the TEAMCITY_DATA_PATH environment variable. The default path suggested for the directory is: %ALLUSERSPROFILE%\JetBrains\TeamCity.
Since TeamCity 9.1, the installer does not ask for the TeamCity data directory and it can be configured on the first TeamCity start.


Recommendations as to choosing Data Directory Location

Note that by default the system directory stores all the artifacts and build logs of the builds in the history and can be quite large, so it is recommended to place TeamCity Data Directory on a non-system disk. Refer to Clean-Up section to configure automatic cleaning of older builds.

Note that TeamCity assumes reliable and persistent read/write access to TeamCity Data Directory and can malfunction if data directory becomes inaccessible. This malfunctions can affect TeamCity functioning while the directory is unavailable and may also corrupt data of the currently running builds. While TeamCity should tolerate occasional data directory inaccessibility, still under rare circumstances the data stored in the directory can be corrupted and be partially lost.

We do not recommend to place the entire TeamCity data directory to a remote/network folder. If a single local disk cannot store all the data, consider placing the data directory on a local disk and mapping .BuildServer/system/artifacts to a larger disk with the help of OS-provided file system links. Since TeamCity 9.1, you can configure multiple artifacts paths.
Related feature request: TW-15251.

Structure of TeamCity Data Directory

The config subdirectory of TeamCity Data Directory contains the configuration of your TeamCity projects, and the system subdirectory contains build logs, artifacts, and database files (if internal database (HSQLDB) is used which is default). You can also review information on Manual Backup and Restore to understand better which data is stored in the database, and which is on the file system.

  • .BuildServer/config — a directory where projects, build configurations and general server settings are stored
    • _trash — backup copies of deleted projects, it is OK to delete them manually. or details on restoring the projects check How To...#Restore Just Deleted Project
    • _notifications — notification templates and notification configuration settings, including syndication feeds template
    • _logginginternal server logging configuration files, new files can be added to the directory
    • projects — a directory which contains all project-related settings. Each project has its own directory. Project hierarchy is not used and all the projects have a corresponding directory residing directly under "projects"
      • <projectID> - a directory containing all the settings of a project with the "<projectID>" id (including build configuration settings and excluding subproject settings). New directories can be created provided they have mandatory nested files. The _Root dicrectory contains settings of the root project. Whenever *.xml.N files occur under the directory, they are backup copies of corresponding files created when a project configuration is changed via the web UI. These backup copies are not used by TeamCity.
        • buildNumbers — a directory which contains <buildConfigurationID>.buildNumbers.properties files which store the current build number counter for the corresponding build configuration
        • buildTypes — a directory with <buildConfiguration or template ID>.xml files with corresponding build configuration or template settings
        • pluginData — a directory to store optional and plugin-related project-level settings. Bundled plugins settings and auxiliary project settings like custom project tabs are stored in plugin-settings.xml file in the directory
        • vcsRoots — a directory which contains project's VCS roots settings in the files _<VcsRootID>.xml
          project-config.xml — the project configuration file containing the project settings, such as parameters and clean-up rules.

main-config.xml — server-wide configuration settings
database.properties — database connection settings, see more at Setting up an External Database
license.keys — a file which stores the license keys entered into TeamCity
change-viewers.propertiesExternal Changes Viewer configuration properties, if available
internal.properties — file for specifying various internal TeamCity properties. It is not present by default and needs to be created if necessary
auth-config.xml — a file storing server-wide authentication-related settings
ldap-config.propertiesLDAP authentication configuration properties
ntlm-config.propertiesWindows domain authentication configuration properties
issue-tracker.xml — issue tracker integration settings
cloud-profiles.xml — Cloud (e.g. Amazon EC2) integration settings
backup-config.xml — web UI backup configuration settings
roles-config.xml — roles-permissions assignment file
database.*.properties — default template connection settings files for different external databases
*.dtd — DTD files for the XML configuration files
*.dist — default template configuration files for the corresponding files without .dist. See below.

  • .BuildServer/plugins — a directory where TeamCity plugins can be stored to be loaded automatically on the TeamCity start. New plugins can be added to the directory. Existing ones can be removed while the server is not running. The structure of a plugin is described in Plugins Packaging.
    • .unpacked — directory that is created automatically to store unpacked server-side plugins. Should not be modified while the server is running. Can be safely deleted if the server is not running.
    • .tools — create this directory to centralize tools to be installed on all agents. Any folder or .zip file under this folder will be distributed to all agents and appear under <agent root>/tools folder.
  • .BuildServer/system — a directory where build results data is stored. The content of the directory is generated by TeamCity and is not meant for manual editing.
    • artifacts — the default directory where the builds' artifacts, logs and other data are stored. The format of the artifact storage is <project ID>/<build configuration name>/<internal_build_id>. If necessary, the files in each build's directory can be added/removed manually - this will be reflected in the corresponding build's artifacts.
      • .teamcity subdirectory stores build's hidden artifacts and build logs (see below). The files can be deleted manually, if necessary, but the build will lack the corresponding feature backed by the files (like the build log, displaying/using finished build parameters, coverage reports, etc.)
        • logs subdirectory stores build logs in an internal format. Build logs store the build output, compilation errors, test output and test failure details. The files can be removed manually, if necessary, but corresponding builds will drop build log and failure details (as well as test failure details).
    • messages — a directory where build logs used to be stored before TeamCity 9.0. After automatic build logs migration to the new place under artifacts, the directory stores the files which could not be moved (see server log on the server start about details).
    • changes — a directory where the remote run changes are stored in internal format. Name of the files inside the directory contains internal personal change id. The files can be deleted manually, if necessary, but corresponding personal builds will lose personal changes in UI and when affected queued builds try to start, they fail or run without personal patch.
    • pluginData — a directory where various plugins can store their data. It is not advised to delete or modify the directory. (e.g. state of build triggers is stored in the directory)
      • audit — directory holding history of the build configuration changes and used to display diff of the changes. Also stores related data in the database.
      • repositoryStates — directory holding current state of the VCS roots. If dropped, some changes might not be detected by TeamCity (between the state last queried by TeamCity and the current state after first server start without this data.
    • caches — a directory with internal caches (of the VCS repository contents, search index, other). It can be manually deleted to clear caches: they will be restored automatically as needed. It is safer to delete the directory while server is not running.
    • buildserver.* — a set of files pertaining to the embedded HSQLDB.
  • .BuildServer/backup — default directory to store backup archives created via web UI. The files in this directory are not used by TeamCity and can be safely removed if they were already copied for safekeeping.
  • .BuildServer/lib/jdbc — directory that TeamCity uses to search for database drivers. Create the directory if necessary. TeamCity does not manage the files in the directory, it only scans it for .jar files that store the necessary driver.

Direct Modifications of Configuration Files

The files under the config directory can be edited manually (unless explicitly noted). The changes will be taken into account without the server restart. TeamCity monitors these files for changes and rereads them automatically when modifications or new files are detected. Bear in mind that it is easy to break the physical or logical structure of these files, so edit them with extreme caution. Always back up your data before making any changes.

Please note that the format of the files can change with newer TeamCity versions, so the files updating procedure might need adjustments after an upgrade.

The REST API has means for most common settings editing and is more stable in terms of functioning after the server upgrade.

.dist Template Configuration Files

Many configuration files meant for manual editing use the following convention:

  • Together with the file (suppose named fileName) there comes a file fileName.dist. .dist files are meant to store default server settings, so that you can use them as a sample for fileName configuration. The .dist files should not be edited manually as they are overwritten on every server start. Also, .dist files are used during the server upgrade to determine whether the fileName files were modified by user, or the latter can be updated.

XML Structure and References

If you plan to modify the configuration manually, note that there are entries interlinked by ids. Examples of such entries are build configuration -> VCS roots links and Project -> parent project links. All the entries of the same type must have unique ids in the entire server. New entries can be added only if their ids are unique.

See also related comment in our issue tracker on build configurations move between TeamCity servers.

See also:

Installation and Upgrade: TeamCity Data Backup

  • No labels