Pricing Adjustments for TeamCity Integration for Jira

June 30, 2022
#News
4 min

We would like to inform our community and the customers of the TeamCity for Jira Integration app of the upcoming price changes that will affect all hostings (Cloud, Server, and Data Center).

Since the first release of the app, we have extensively invested in the development of new features, provision of timely and effective support, and, of course, collaboration with you on improvements and adjustments within the app. 

Our operational costs have greatly increased since that time, and at the moment we are heavily developing the Data Center infrastructure to ensure the reliability and high performance of our app under any circumstances.

Over the years, we were working to improve services for you and provide the best quality for your satisfaction. Thus, we’ve decided to normalize the existing prices and, in particular, make the Cloud version of the app more cost-effective.

For all hostings, the price change will go into effect on August 1, 2022. Below are the new pricing models.

Cloud Pricing

Data Center Pricing

Server Pricing

Buy at today’s price

You can buy TeamCity for Jira Integration at the current price till August 1, 2022. To save up even more, go with 2 or 3-year licenses — the price will remain the same for the whole maintenance period.

But even after August 1, 2022, existing customers with commercial licenses get a 60-day grandfathering period (till September 30, 2022), so you’ll have 60 days more to renew your license for the old price.

Have questions?

Please, feel free to contact us if you have any questions or need our assistance.

How to automatically deploy add-ons to JIRA, Confluence, Bitbucket using TeamCity

August 25, 2016
#How To#Bitbucket#Integration
2 min

Connect your Bitbucket to the TeamCity CI/CD server with TeamCity Integration for Bitbucket to run builds right from Bitbucket in one click, view build results, logs and artifacts right next to your code, and never lose time switching.

TeamCity from JetBrains is one of most famous systems that people use to build their own continous integration and continous delivery solutions. We at StiltSoft use TeamCity in our development process for different purposes, as follows:

  • building add-ons
  • running integration tests for checking add-on issues before their deployment to production systems
  • running the code quality analysis with SonarQube
  • deploying updates or add-ons to our test, staging or production instances

Today we’re going to tell you how to use TeamCity for automatic deployment of add-ons to Atlassian JIRAConfluence or Bitbucket.

Continue reading “How to automatically deploy add-ons to JIRA, Confluence, Bitbucket using TeamCity”

How to integrate TeamCity 10 and Jira

May 12, 2016
#How To#Jira#Integration
3 min

Connect your Bitbucket to the TeamCity CI/CD server with TeamCity Integration for Bitbucket to run builds right from Bitbucket in one click, view build results, logs and artifacts right next to your code, and never lose time switching.

Atlassian JIRA has become, probably, the most popular bug tracker solution. It’s not surprising because it has a powerful set of features, flexible configuration and can be integrated with a variety of other solutions (especially developed by Atlassian). JIRA allows you to create different solutions for different tasks. It can be used for tracking simple home or family tasks (with a 10-user license that costs only $10), it can be also used for building a full-fledged enterprise task management and bug tracking solution with service desk. JIRA, starting from version 7, represents a platform for different applications. At the moment, there are three applications:

– JIRA Core – basic version of JIRA for tracking the tasks in the simple projects
– JIRA Software – old good JIRA that we know – with all its essentilal capabilities, including Kanban and Scrum
– JIRA Service Desk – service desk solution by Atlassian based on JIRA

TeamCity – one of the common and well-proven CI-solutions from JetBrains. It can be used by small teams of developers (there is a free version of TeamCity for small instances), but it also can be used as an enterprise CI-solution for the large companies. TeamCity allows you to automate build, test and deploy workflows.

We’re  using in StiltSoft both JIRA and TeamCity for a development process. We’re updating our JIRA and TeamCity instances every time when a new version is available and we haven’t had any problems yet. JIRA 7 was released by Atlassian last year, and now JetBrains team is preparing TeamCity 10 to release (EAP already available). Let’s sort out what’s new in TeamCity 10.

Continue reading “How to integrate TeamCity 10 and Jira”

How to Integrate TeamCity and Bitbucket Server

April 20, 2016
#How To#Bitbucket
10 min

Bitbucket is a centralized development management solution for controlling your repositories behind the firewall. It allows you to simplify the procedures of hosting an internal source code control server and provide easy access to your repositories for all your team members.

In the IT world, it is not a secret that Bitbucket can be integrated with other software products and platforms into a single ecosystem that makes the entire development process comprehensive and convenient. Most times, people integrate Bitbucket with Jira. But localization and resolution of the issue is not the only problem, which a generic development encounters every day, several times a day. But it is more important to preserve the project integrity while adding modifications or corrections into the program code. For these purposes, you can use the continuous integration server that can also create project builds and run a series of tests for automatic verification of functionality.

With the introduction of the Integrated CI/CD, Atlassian extended the list of platforms supported out-of-the-box, so you can now link Bitbucket Data Center and Server with Bamboo or Jenkins. But it doesn’t mean that TeamCity users have to miss out on the integration benefits, and in this blog post, we will show how to link your Bitbucket and TeamCity and get the most of it.

View build statuses with Commit Status Publisher

First of all, we would like to present the native add-on from the developers of TeamCity because native integration tools are usually convenient, well-thought, and rich in features. 

Commit Status Publisher is an open-source plugin that comes bundled with TeamCity (since version 10.0) and allows it to automatically send build statuses of the commits to an external system.

To enable the transfer of the statuses to Bitbucket, you need to add a Build Feature with Commit Status Publisher type in the Build Configuration Settings 

And then set it up for Bitbucket.

Once the configuration is complete, run the application build and ensure that Bitbucket received data from TeamCity. If everything worked correctly, from now you’ll be able to see the build statuses on the Builds page.

Apart from the Builds page, builds statuses are indicated on the Commits and Branches pages. If you select any build status icon, it will take you to the Builds page with the filter set to that commit or branch.

While viewing the pull request details, you’ll see build status on the Overview tab or go straight to the Builds page to see builds information for each commit.

Run builds, access artifacts and logs without leaving Bitbucket

If you don’t want to spend time switching tools and would like to operate on your builds without losing the context, you can get a more advanced integration with TeamCity using the TeamCity Integration for Bitbucket app. It provides a seamless way to connect your Bitbucket to the TeamCity server, so you can monitor and configure the pipeline without leaving Bitbucket. Using it, you can:

  • Run builds
  • View build results
  • Access logs and artifacts via direct links.

After you installed the app to your instance, you need to authorize TeamCity in Bitbucket using access tokens.

You can create an access token in your TeamCity profile.

Now add the token to your profile in Bitbucket. Click on your avatar in the header and then on Manage account, choose TeamCity tab in the navigation bar and add the token.

You can enhance the integration by adding the Commit Status Publisher to your build configuration. 

Go to the Configuration Settings on a build page in TeamCity, click on the Build Features, Add Commit Status Publisher and set it up for Bitbucket as described a few paragraphs above.

Now you’re all set and can get to work with the app. On the Builds page, you can view build statuses, links to logs and artifacts, and perform build actions. At the moment, the list of actions include:

  • Build the latest commit — running a build for the latest commit in the current branch.
  • Re-build this commit — re-running a build for a particular commit.

You can also find build information on the Pull Requests page. The latest build statuses are shown in the Overview tab, while the Builds tab allows to act on builds and view builds’ logs and artifacts, similarly to the main Builds page.

TeamCity Integration for Bitbucket is available for a free 30-day trial on the Marketplace both for Bitbucket Server and Bitbucket Data Center. We have step-by-step guides to get you started faster, but if you have any questions about the app or feedback you’d like to share, create a ticket in our Help Center.

Integrate to improve

You can enhance your DevOps toolchain with the help of integrations described in the article to improve developers’ velocity as well as time to production. Which one to choose depends on your requirements and personal preferences. Write in the comments, which one you use or would use, and share your opinion about these integrations.

Get Мaximum from TeamCity Integration through REST API

November 12, 2015
#How To#Jira#Integration
28 min

Connect your Bitbucket to the TeamCity CI/CD server with TeamCity Integration for Bitbucket to run builds right from Bitbucket in one click, view build results, logs and artifacts right next to your code, and never lose time switching.

Working in a team is a great challenge when you need close collaboration between different people of different occupations and specializations. This becomes a real pain when members of a team do not have direct communication or communication is complicated with external factors. Here come special collaboration platforms that leverage the gap between people and create a single environment for peer-to-peer interaction and efficient knowledge or information sharing.

Today we will try to review an environment of TeamCityJIRA and Confluence integrated into a single ecosystem for quick and easy data retrieval about builds and agents from TeamCity.

So what capabilities does this integration offer to the team of software developers? First of all, Confluence can be used as a collaboration platform listing the latest builds within the appropriate project and configuration. Project Managers and Team Leads can be always aware of the progress on the project and track the current activity on project development. JIRA can be used by developers and quality assurance engineers. Developers can track progress on issues and tasks, and quality assurance engineers can track the completion of development and proceed to testing of functionality.

TeamCity is already bundled with JIRA integration capabilities, but Atlassian JIRA does not have a native tool that can fetch build data and show it in JIRA issues, the same is true and for Confluence. The solution from StiltSoft team allows you to establish full-fledged integration between TeamCity, JIRA and Confluence, in addition to standard integration from JetBrains team available in Teamcity.

In our blog post we will show how you can create tools for fetching data from TeamCity via Rest API and showing this build data in some application.

Connecting to TeamCity Server

TeamCity provides REST API, which powerful capabilities can be used for fetching various data from TeamCity server. You need to send a HTTP request to REST API to fetch the required piece of TeamCity data. In order to get the requested piece of data you need to authorize on the server through one of the following ways:

  1. Basic HTTP Authentication – you need to provide the appropriate TeamCity username and password with the request. In this case, you need to include ‘httpAuth’ into your GET request: http://teamcity-server/httpAuth/app/rest/builds.
  2. Guest Authentication – you needn’t provide the valid username and password, just include ‘guestAuth’ into your GET request: http://teamcity-server/guestAuth/app/rest/builds.

Once your request has been processed, TeamCity server will return a piece of XML data, which you can further parse and output into your application.

Fetch Useful Build Data

First of all, TeamCity server stores a lot of build data, which is the point of interest #1 for you. Build data contains a lot of useful information about builds, their status, time for execution, completion status of tests and related issues in the issue tracking system. The best way is to fetch builds in batches – 20 or 50 builds per batch. You can use the following request to REST API of TeamCity server:

curl -D- -u guest:guest -X GET -H "Content-Type: text/xml" -k https://teamcity-server/httpAuth/app/rest/builds?locator=canceled:any,count:20,start:20,branch:(default:any)

You get a XML response with 20 builds, as follows:

<builds count="20" href="/httpAuth/app/rest/builds?locator=canceled:any,count:20,start:20,branch:(default:any)" nextHref="/httpAuth/app/rest/builds?locator=canceled:any,count:20,start:40,branch:(default:any)" prevHref="/httpAuth/app/rest/builds?locator=canceled:any,count:20,start:0,branch:(default:any)">
 <!--The piece of code is omitted -->
 <build id="6863" buildTypeId="SmartAttachments_Master" number="87" status="SUCCESS" state="finished" branchName="master" defaultBranch="true" href="/httpAuth/app/rest/builds/id:6863" webUrl="http://teamcity.stiltsoft.com/viewLog.html?buildId=6863&buildTypeId=SmartAttachments_Master"/>
 <build id="6862" buildTypeId="SmartAttachments_Master" number="86" status="SUCCESS" state="finished" branchName="master" defaultBranch="true" href="/httpAuth/app/rest/builds/id:6862" webUrl="http://teamcity-server/viewLog.html?buildId=6862&buildTypeId=SmartAttachments_Master"/>
 <build id="6861" buildTypeId="SmartAttachments_Master" number="85" status="SUCCESS" state="finished" branchName="master" defaultBranch="true" href="/httpAuth/app/rest/builds/id:6861" webUrl="http://teamcity-server/viewLog.html?buildId=6861&buildTypeId=SmartAttachments_Master"/>
 <build id="6860" buildTypeId="SmartAttachments_Master" number="84" status="SUCCESS" state="finished" branchName="master" defaultBranch="true" href="/httpAuth/app/rest/builds/id:6860" webUrl="http://teamcity-server/viewLog.html?buildId=6860&buildTypeId=SmartAttachments_Master"/>
 <build id="6859" buildTypeId="SmartAttachments_Master" number="83" status="SUCCESS" state="finished" branchName="master" defaultBranch="true" href="/httpAuth/app/rest/builds/id:6859" webUrl="http://teamcity-server/viewLog.html?buildId=6859&buildTypeId=SmartAttachments_Master"/>
 <!--The piece of code is omitted -->
 <build id="6856" buildTypeId="SmartAttachments_Master" number="82" status="SUCCESS" state="finished" branchName="master" defaultBranch="true" href="/httpAuth/app/rest/builds/id:6856" webUrl="http://teamcity-server/viewLog.html?buildId=6856&buildTypeId=SmartAttachments_Master"/>
 <build id="6855" buildTypeId="SmartAttachments_Master" number="81" status="SUCCESS" state="finished" branchName="master" defaultBranch="true" href="/httpAuth/app/rest/builds/id:6855" webUrl="http://teamcity-server/viewLog.html?buildId=6855&buildTypeId=SmartAttachments_Master"/>
 <build id="6854" buildTypeId="SmartAttachments_Master" number="80" status="SUCCESS" state="finished" branchName="master" defaultBranch="true" href="/httpAuth/app/rest/builds/id:6854" webUrl="http://teamcity-server/viewLog.html?buildId=6854&buildTypeId=SmartAttachments_Master"/>
</builds>

You can further parse this build data and use it for output to the interface of your application.

Additionally, you can get detailed information about each build from the batch by making the following request:

<code class="java plain" style="color: #000000 !important;">curl -D- -u guest:guest -X GET -H </code><code class="java string" style="color: #003366 !important;">"Content-Type: text/xml"</code> <code class="java plain" style="color: #000000 !important;">-k https:</code><code class="java comments" style="color: #008200 !important;">//teamcity-server/httpAuth/app/rest/builds/id:378626</code>

The XML response you get will be the following:

<build id="6854" buildTypeId="SmartAttachments_Master" number="80" status="SUCCESS" state="finished" branchName="master" defaultBranch="true" href="/httpAuth/app/rest/builds/id:6854" webUrl="http://teamcity-server/viewLog.html?buildId=6854&buildTypeId=SmartAttachments_Master">
 <statusText>Success</statusText>
 <buildType id="SmartAttachments_Master" name="Master" projectName="Smart Attachments" projectId="SmartAttachments" href="/httpAuth/app/rest/buildTypes/id:SmartAttachments_Master" webUrl="http://teamcity-server/viewType.html?buildTypeId=SmartAttachments_Master"/>
 <queuedDate>20141128T133710+0300</queuedDate>
 <startDate>20141128T133710+0300</startDate>
 <finishDate>20141128T133725+0300</finishDate>
 <triggered type="vcs" details="jetbrains.git" date="20141128T133710+0300"/>
 <lastChanges count="1">
 <change id="4927" version="f6b67f30820c02182b24ca9d596d24a0fb74b602" username="akhaneev" date="20141128T132640+0300" href="/httpAuth/app/rest/changes/id:4927" webUrl="http://teamcity-server/viewModification.html?modId=4927&personal=false"/>
 </lastChanges>
 <changes href="/httpAuth/app/rest/changes?locator=build:(id:6854)"/>
 <revisions count="1">
 <revision version="f6b67f30820c02182b24ca9d596d24a0fb74b602">
 <vcs-root-instance id="541" vcs-root-id="SmartAttachments_HttpsStashStiltsoftComScmAcaAttachmentCategoryAddOnGit" name="https://stash-server/scm/aca/attachment-category-add-on.git" href="/httpAuth/app/rest/vcs-root-instances/id:541"/>
 </revision>
 </revisions>
 <agent href="/httpAuth/app/rest/agents/id:2" id="2" name="tm7" typeId="2"/>
 <artifacts href="/httpAuth/app/rest/builds/id:6854/artifacts/children"/>
 <relatedIssues href="/httpAuth/app/rest/builds/id:6854/relatedIssues"/>
 <statistics href="/httpAuth/app/rest/builds/id:6854/statistics"/>
</build>

If you want to find out the related issues, you can perform an additional request which fetches information about the related issues in the issue tracker (for example, YouTrack or JIRA):

curl -D- -u guest:guest -X GET -H "Content-Type: text/xml" -k https://teamcity-server/httpAuth/app/rest/builds/id:378549/relatedIssues

You will receive the following XML response from TeamCity server:

<issuesUsages count="1" href="/httpAuth/app/rest/builds/id:6854/relatedIssues">
 <issueUsage>
 <changes count="1">
 <change id="4927" version="f6b67f30820c02182b24ca9d596d24a0fb74b602" username="akhaneev" date="20141128T132640+0300" href="/httpAuth/app/rest/changes/id:4927" webUrl="http://teamcity-server/viewModification.html?modId=4927&personal=false"/>
 </changes>
 <issue id="SMART-40" url="https://jira-server/browse/SMART-40"/>
 </issueUsage>
</issuesUsages>

You can use the received project key and issue number for mapping to the particular issue in the issue tracking system.

Quality assurance engineers can easily monitor the status of each issue and can instantly proceed to functionality testing once the corresponding build with the fix is complete. So they needn’t wait for the development team when someone will resolve this issue in the issue tracking system.

TeamCity Integration through REST API

Find Out Available TeamCity Agents

You can also retrieve information about build agents and get the list of the currently active agents. This can be useful for the quality assurance engineer and developers to track availability of the specific build agent at the definite period of time. You can make the following request to display the list of available build agents:

curl -D- -u guest:guest -X GET -H "Content-Type: text/xml" -k  https://teamcity-server/httpAuth/app/rest/agents

You will get the following XML data about build agents:

<agents count="2" href="/httpAuth/app/rest/agents">
 <agent href="/httpAuth/app/rest/agents/id:4" id="4" name="teamcity2k8" typeId="4"/>
 <agent href="/httpAuth/app/rest/agents/id:2" id="2" name="tm7" typeId="2"/>
</agents>

If needed, you can get detailed information about a specific agent, you should use the following request with the ID of the required agent:

curl -D- -u guest:guest -X GET -H "Content-Type: text/xml" -k  https://teamcity-server/httpAuth/app/rest/agents/id:4

You will receive the following XML data about the agent with the list of its requirements for running builds:

<agent href="/httpAuth/app/rest/agents/id:4" id="4" name="teamcity2k8" typeId="4" connected="true" enabled="true" authorized="true" uptodate="true" ip="192.168.0.31">
 <properties count="145">
 <property name="DotNetFramework2.0.50727_x64_Path" value="C:\Windows\Microsoft.NET\Framework64\v2.0.50727"/>
 <property name="DotNetFramework2.0.50727_x86_Path" value="C:\Windows\Microsoft.NET\Framework\v2.0.50727"/>
 <property name="DotNetFramework2.0_x64" value="2.0.50727"/>
 <!-- The piece of code is omitted -->
 <property name="DotNetFramework2.0_x86_Path" value="C:\Windows\Microsoft.NET\Framework\v2.0.50727"/>
 <property name="teamcity.tool.maven3" value="C:\BuildAgent\tools\maven3"/>
 <property name="teamcity.tool.maven3_1" value="C:\BuildAgent\tools\maven3_1"/>
 <property name="teamcity.tool.maven3_2" value="C:\BuildAgent\tools\maven3_2"/>
 </properties>
 <pool id="0" name="Default" href="/httpAuth/app/rest/agentPools/id:0"/>
</agent>

Developers can easily view which build agents are currently in use by other projects and start building the project with another agent. The list of agents can be shown as a gadget on JIRA dashboard or placed as a macro on some Confluence page.

TeamCity Integration through REST API

Optionally, you can also get information about the agent pools. Agent pool is a separate group of build agents that are assigned to the specific project for running builds. Any project can be assigned to multiple agent pools. Each build agent can be only assigned to one agent pool. You can run project builds only on build agents from pools assigned to the project. By default, all newly authorized agents are included into the Default pool. Agent pools allow you to bind specific agents to specific projects.

Just perform the following request:

curl -D- -u guest:guest -X GET -H "Content-Type: text/xml" -k https://teamcity-server/httpAuth/app/rest/agentPools/id:0

In the outputted listing you will get the following XML data:

<agentPool id="0" name="Default" href="/httpAuth/app/rest/agentPools/id:0">
 <projects count="15">
 <project id="TableFilter" name="TableFilter" parentProjectId="_Root" href="/httpAuth/app/rest/projects/id:TableFilter" webUrl="http://teamcity.stiltsoft.com/project.html?projectId=TableFilter"/>
 <project id="_Root" name="<Root project>" description="Contains all other projects" href="/httpAuth/app/rest/projects/id:_Root" webUrl="http://teamcity.stiltsoft.com/project.html?projectId=_Root"/>
 <project id="InPlaceEditorforConfluence" name="InPlace Editor for Confluence" parentProjectId="_Root" href="/httpAuth/app/rest/projects/id:InPlaceEditorforConfluence" webUrl="http://teamcity.stiltsoft.com/project.html?projectId=InPlaceEditorforConfluence"/>
 <!-- The piece of code is omitted -->
 <project id="ConfluenceTalkPlugin" name="Confluence Talk Plugin" parentProjectId="_Root" href="/httpAuth/app/rest/projects/id:ConfluenceTalkPlugin" webUrl="http://teamcity.stiltsoft.com/project.html?projectId=ConfluenceTalkPlugin"/>
 <project id="SmartAttachments" name="Smart Attachments" parentProjectId="_Root" href="/httpAuth/app/rest/projects/id:SmartAttachments" webUrl="http://teamcity.stiltsoft.com/project.html?projectId=SmartAttachments"/>
 <project id="NoEmailStorm" name="No Email Storm" parentProjectId="_Root" href="/httpAuth/app/rest/projects/id:NoEmailStorm" webUrl="http://teamcity.stiltsoft.com/project.html?projectId=NoEmailStorm"/>
 </projects>
 <agents count="2">
 <agent href="/httpAuth/app/rest/agents/id:4" id="4" name="teamcity2k8" typeId="4"/>
 <agent href="/httpAuth/app/rest/agents/id:2" id="2" name="tm7" typeId="2"/>
 </agents>
</agentPool>

The listing shows the following information:

  • projects that can be built by the agents from the pool
  • list of agents within the pool

Discover Your Projects in TeamCity

TeamCity API allows you to retrieve information about projects by performing the following request to the server:

curl -D- -u guest:guest -X GET -H "Content-Type: text/xml" -k https://teamcity-server/httpAuth/app/rest/projects/

The response will include the list of projects available in TeamCity, as follows:

<projects count="15" href="/httpAuth/app/rest/projects">
 <project id="AWEGRAPHS" name="Awesome Graphs for Stash" parentProjectId="_Root" href="/httpAuth/app/rest/projects/id:AWEGRAPHS" webUrl="http://teamcity.stiltsoft.com/project.html?projectId=AWEGRAPHS"/>
 <!-- The piece of code is omitted -->
 <project id="SmartAttachments" name="Smart Attachments" parentProjectId="_Root" href="/httpAuth/app/rest/projects/id:SmartAttachments" webUrl="http://teamcity.stiltsoft.com/project.html?projectId=SmartAttachments"/>
 <project id="TeamCityIntegrationLibrary" name="TeamCity Connector" parentProjectId="JiraTeamCityIntegration" href="/httpAuth/app/rest/projects/id:TeamCityIntegrationLibrary" webUrl="http://teamcity.stiltsoft.com/project.html?projectId=TeamCityIntegrationLibrary"/>
 <project id="ConfluenceTeamCityIntegration" name="TeamCity Integration for Confluence" parentProjectId="JiraTeamCityIntegration" href="/httpAuth/app/rest/projects/id:ConfluenceTeamCityIntegration" webUrl="http://teamcity.stiltsoft.com/project.html?projectId=ConfluenceTeamCityIntegration"/>
 <project id="JiraTeamCityIntegration_TeamCityIntegrationForJira" name="TeamCity Integration for JIRA" parentProjectId="JiraTeamCityIntegration" href="/httpAuth/app/rest/projects/id:JiraTeamCityIntegration_TeamCityIntegrationForJira"webUrl="http://teamcity.stiltsoft.com/project.html?projectId=JiraTeamCityIntegration_TeamCityIntegrationForJira"/>
 <project id="BambooVMwarePlugin" name="Virtual Agents for Bamboo" parentProjectId="_Root" href="/httpAuth/app/rest/projects/id:BambooVMwarePlugin" webUrl="http://teamcity.stiltsoft.com/project.html?projectId=BambooVMwarePlugin"/>
</projects>

Additionally, you can also fetch data about the project by entering the corresponding project name into the request:

curl -D- -u guest:guest -X GET -H "Content-Type: text/xml" -k https://teamcity-server/httpAuth/app/rest/projects/id:Project_name

You will get the following XML listing:

<project id="SmartAttachments" name="Smart Attachments" parentProjectId="_Root" href="/httpAuth/app/rest/projects/id:SmartAttachments" webUrl="http://teamcity.stiltsoft.com/project.html?projectId=SmartAttachments">
 <parentProject id="_Root" name="<Root project>" description="Contains all other projects" href="/httpAuth/app/rest/projects/id:_Root" webUrl="http://teamcity.stiltsoft.com/project.html?projectId=_Root"/>
 <buildTypes count="2">
 <buildType id="SmartAttachments_Master" name="Master" projectName="Smart Attachments" projectId="SmartAttachments" href="/httpAuth/app/rest/buildTypes/id:SmartAttachments_Master" webUrl="http://teamcity.stiltsoft.com/viewType.html?buildTypeId=SmartAttachments_Master"/>
 <buildType id="SmartAttachments_MasterIt" name="Master IT" projectName="Smart Attachments" projectId="SmartAttachments" href="/httpAuth/app/rest/buildTypes/id:SmartAttachments_MasterIt" webUrl="http://teamcity.stiltsoft.com/viewType.html?buildTypeId=SmartAttachments_MasterIt"/>
 </buildTypes>
 <templates count="0"/>
 <parameters count="0" href="/app/rest/projects/id:SmartAttachments/parameters"/>
 <vcsRoots count="1" href="/httpAuth/app/rest/vcs-roots?locator=project:(id:SmartAttachments)"/>
 <projects count="0"/>
</project>

The XML output will include the following information:

  • project name
  • parent project (if applicable for the current project)
  • list of the latest build types of the project
  • project description

The project manager or team lead can get a simple picture of the project development in JIRA. The project will show the listing of builds and their relations to the created JIRA issues.

TeamCity Integration through REST API

Alternatively, the project manager can use a macro on Confluence page and view the committed code changes per branch.

confluence_teamcity_data_viewing

Results

REST API of TeamCity is a powerful and rich-in-features interface for getting build data and showing it in your application or system. It provides simple and easy-to-use requests for fetching data from TeamCity server, and even beginners can quickly start using it for building their custom solutions. Besides retrieving data from TeamCity server, you can also update or delete build data depending on the complexity and requirements of your project.

If you want to try integration of TeamCity server with Atlassian products, try our add-ons – TeamCity Integration for JIRA and TeamCity Integration for Confluence. If you have any questions or ideas, feel free to contact us at any time.

TeamCity Integration for JIRA breaks into Enterprise!

November 26, 2014
#Jira#Integration
6 min

Not long time ago Atlassian announced release of Enterprise solution – JIRA Data Center. This solution was designed as a high availability and top performance platform for large instances hosted in a dedicated data center.

JIRA Data Center provides you with uninterrupted access to critical services, distributes the load proportionally across the nodes and saves you from any unexpected hardware failures and data losses. Other benefits include a capability to route the appropriate applications to the specific node within the cluster and add new nodes in the real-time mode.

We have being developing add-ons for JIRA for several years, and like Atlassian understand the necessity to adjust our products to requirements of enterprise customers. After the long-lasting development, enhancement and optimization we are proud to say that the TeamCity Integration for JIRA add-on has been significantly improved to meet actual needs of the most demanding enterprise users.

JIRA Data Center

Starting from TeamCity Integration for JIRA 1.7.3 we added support for JIRA Data Center. Enterprise customers usually have complex infrastructure comprised of multiple TeamCity servers and a great number of users working with JIRA and fetching data from continuous integration servers. This stipulates high accessibility and instant response of the system that are available in JIRA Data Center.

jira and teamcity integration

Support for Multiple TeamCity Servers

Enterprise customers usually have several TeamCity servers, which data about builds should be available in one place – in JIRA. Now the add-on allows you to view information about builds from multiple TeamCity servers within the associated JIRA issue and see availability of build agents per each server. You can connect as many as needed TeamCity servers to your JIRA just by adding the corresponding application links.

teamcity servers

Persistent Data Storage

Some customers may also have TeamCity servers storing millions of builds. This fact affects availability of data in JIRA after its restart or update of the add-on. This can be achieved only through maximally quick data indexation and rapid data access to the requested information. The persistent storage for TeamCity data addresses all these issues and lets you always get quick access and maximal data availability after the scheduled maintenance work.

Indexation Optimization

TeamCity servers storing millions of builds can be slow due to large data amounts and can be even inaccessible because of the periodical clean-up. The continuous integration server may also store some abnormal builds with up to 10,000 commits and requests, which comprise two-gigabyte response from TeamCity server during data indexing.

That’s why the add-on has received several options, such as Response TimeoutSocket TimeoutConnection Timeout that allow you to adjust data indexation and speed up the entire process from large TeamCity Servers. The three other options – Index DepthResponse Size and Skip Builds – allow you to limit depth of TeamCity data indexation and better handle abnormal builds with a capability to skip them from the indexing.

teamcity configuration

We hope that you will like the updated version of TeamCity Integration for JIRA. If you still have any questions or encounter any issues, feel free to contact us at any time.