Skip to end of metadata
Go to start of metadata

What is the Atlassian IDE Connector?

The Atlassian IDE Connector is an add-on for your integrated development environment (IDE). It allows you to work with the Atlassian products within your IDE. Now you don't have to switch between websites, email messages and new feeds to see what's happening to your project and your code. Instead, you can see the relevant JIRA issues, Crucible reviews and Bamboo build information right there in your development environment.

Supported IDEs

The Atlassian IDE Connector is available for IDEA and Eclipse.

In the future we will develop plugins for other IDEs, such as and Visual Studio.


What are we doing? What will we build?


For more information, please refer to the IDE Connector documentation.

Development Blog

If you want to monitor the development process (see what the future will bring, our ideas, and so on) please subscribe to our blog.

You can use one or more of these methods to read the blog posts:

  • Subscribe to this RSS feed and view it in your own RSS reader.
  • Visit the IDE Connector wiki's News page to browse through all the blog posts.
  • Below are the latest blog posts. Click a title to see the full text.

Latest Blog Posts:

The team together with Edwin Wong decided to suspend development of the Eclipse plugin for next few weeks. The exact time is not known yet. The plan is to put all the force to finish version 2.0 of the Idea plugin. It will contain enhanced Crucible integration (will work only with Curcible 1.6) and is planed to be released more or less in the same time as new Crucible. After that we will resume our work on the Eclipse plugin (existing Bamboo part and new Crucible part).

Are web UI review systems the best?

I was thinking how to make code reviews carried out from IDE like IDEA or Eclipse an interesting alternative for Crucible users (and also users of other web based review systems like ReviewBoard) who got used to their web UI.

For me an "interesting alternative" is when performing review from IDE:

  • is significantly better
  • is significantly different and better in some important aspect

than performing review via web UI.

Why web based review system often suck

My problem with web based code review is (regardless of concrete implementation):

  • web UI is very cumbersome to navigate back and forth between files and file fragments (classes, methods)
  • they are rather diff oriented and reviewers often don't pay enough attention to global implication of innocent changes. Typically you are deprived of the whole project context and can see only those files & their changes which were included in review
  • you are left without so vital and natural in modern IDE features like: finding usage/references of given language element, navigating to implementation, static analysis, code coverage, etc. As result I find myself anyway resorting to using IDE while carrying out most of reviews.
  • I tend to find more value in regular lightweight code reviews of whole classes, packages or components than for the set of changesets spread out through the whole codebase.

Say "no"

I think I finally found the solution. It's very simple but it is not obvious as it requires saying "no" to many requirements and features which could be good in general approach. I was inspired by a great book Getting Real and its chapters about selection of the features (e.g. Start with no).

I say "no" to ability to perform in IDE reviews:

  • for the code in programming language which my IDE does not support
  • for the projects which I don't have IDE configured for
  • which involve obsolete source code which would require me constantly updating/reverting to some old versions/revisions from SCM
  • which concentrate just on modifications introduced by given person and not on the code quality in general

Ultimate solution

My dream is:

  • to carry out code reviews completely from IDE
  • when you start performing review, the plugin in your IDE will download all the information from the server to be able to mark all the code changes included in the review and highlight all the comments.
    you can easily navigate back and forth through all the comments, corresponding code fragment and files included in the review
    the code shown in IDE is your normal code. Not alien, not read-only. If plugin detects that your code currently open in IDE is the same as the one which is included in review, then just the code (e.g. Java file) from your current project is being used.
  • you can use all features of your IDE while analysing the code under review: quickly navigate to implementation (CTRL+click), find all references, implementators, callers, run unit tests, debug code fragments, check unit test coverage, run static code analysis tools (like checkstyle, findbugs, famous IDEA inspections), etc.
  • you could actually modify and commit back the source code which requires changes (if your review policy allows it) instead of just describing how the proper code should look like and thus avoid very time consuming create review/perform review/read reviewers' comments/fix defects/created re-review cycle. Such modification could be linked back to the review.
  • you can add comment at any time at ANY line of ANY file just belonging to the project while you browse the code to analyse the fragments you are reviewing


  • no easy way to perform review of the code which is not the most fresh (HEAD). But is it really a problem? What is the reason to review code which does not exist anyway as it was changed with subsequent commits? The only purpose is educational I believe.
  • you cannot easily review locally modified files. Again you could always use clean working copy for performing reviews. Alternatively you will not be able to review at all locally modified files (but you could the rest). Also it's doable (with some additional work) to write the plugin in such a way that it can handle also locally modified files and block review only for those modified fragments which collide with reviewed code.


I can live with this drawbacks definitely. And in all these cases (95% or more I guess) I will have a system which is vastly better than any web UI code review system.

We can start from IntelliJ IDEA (and all languages it supports) as we are 95% advanced with building blocks to make this dream come true. The next is Eclipse. What next in the future?
It depends on you.

What do you think?

The team focused on the Idea version of the plugin in the past iteration as we want to improve handling Crucible and release it in the same time when new Crucible will appear (probably the end of August but the date is usually postponed few times before final release).

The only features we implemented for Eclipse are showing full build log inside the IDE and browser view for Bamboo servers and plans.

The first feature is self-explanatory. When bamboo build is selected you can click new toolbar button 'Show Build Log' to open read-only editor with build log. Everything is presented on the screenshot. Unfortunately Find/Search does not work in the editor yet.

The second feature provides additional view called 'Bamboo Servers' where we can add bamboo server and browse plans defined on that server. In the future we will use that list to select watched plans (copy them to the 'Bamboo Watched Plans' view), start build on the plan and probably many more.

Next two weeks I'm on the vacation. Unfortunately Pawel, who worked on the 'Bamboo Servers' view decided to leave the company so next two weeks probably no one will work on the Eclipse version of the plugin. Because of that you can expect next version not in two weeks but at the end of the August.



0.3.1 version of the Eclipse plugin has been released.

Only few minor features has been added this time as I had to spend few days working on Idea version of the plugin.

What's new:

  • In configuration dialog you can check 'use favorites' builds so in the bamboo view you will see the list of builds marked as favorites on the bamboo server.
  • In the bamboo view buttons 'label' and 'comment' are active
  • Icon in the status bar informs about general state of watched builds (red means at lest one of the builds failed, green means all builds passed, gray means that there is a connection problem). Double click on the icon opens bamboo view (in case it was hidden).

Empty 'project' and 'server' columns bug has been fixed as well.

We still work on handling multiple bamboo servers which is not finished yet.





For couple of months our team has been working on creating decent IntelliJ IDEA and Eclipse plugins for a few Atlassian developer tools: Crucible, Bamboo, JIRA and FishEye.
During this time we have learned that writing IDE plugins for web applications is not so easy.
Here is why:

  • It's pure integration work. For all who know what "integration" is and that it consumes vast majority of IT budgets in nowadays enterprise environments this single argument is often enough.
  • You shoot at constantly moving targets. Not only you have to follow evolution of IDE API-s (e.g. significant changes between major Eclipse or IDEA releases), but also we have to constantly answer to evolving web applications: their new features, new remote API-s.
  • You are constrained by both application limitations and IDE limitations. Fortunately we can modify on our own our web applications (after all they are from Atlassian (smile)) and when the change is not relatively costly to add (e.g. exposing an existing stuff via REST API), we can quickly add it on the server side. It's not so easy on IDE side. In case of IDEA we just don't have access to sources, in case of Eclipse contributing anything significant is often quite overwhelming unless you are really devoted to extending this platform.
  • You meander in new, complicated and quite specialized technologies
    • closed source for JetBrains IDEA with not-so-well documented OpenAPI. (fortunately folks from JetBrains try to be really helpful)
    • open source for Eclipse, but huge (millions lines of code) and with overwhelming documentation and endless possibilities
      Your long experience as developer does not often help you here.
  • You are often a pioneer who explores new undiscovered areas of IDEs - there is no hints or help at forums or documentation available. You shape the world.
  • You always have to think what to implement on IDE side and what does not make sense. Typically web UI is very powerful (now in AJAX times) and there is no point in just repeating the same on IDE side. The point is to leverage IDE power - the fact that it's code-centric and provides all these facilities to navigate, edit, analyse, run, debug and test the code. For me an IDE plugin for a web application makes only sense when it has a feature (or better many features) which make developer totally dependent (positively) on IDE plugin and very reluctantly resorting to web UI for an operation he normally could better! do from IDE.
  • It may be complex from threading point of view. Remote access to your web application may be slow and faulty. You need to perform most of the operations asynchronously in separate threads. You have to also gracefully handle timeouts, network failures and temporarily outages.
  • Remote communication with web applications impose on you some design limitations. You cannot freely call your web server as many times as you wish (e.g. while traversing object hierarchy) as the performance would be unacceptable. You have to group calls into batches, you have to fetch "deep" objects, you have to sometimes fetch data in chunks (and add subsequent chunks in the background)
  • You may often stumble upon integration-hell and unintended interactions between various plugins from different vendors.
    your automatic testing (both unit and functional) is somewhat difficult (similarly to testing EJB components in old J2EE) - you sometimes just depend on IDE)
  • Plugin is just software. Writing all software is hard (smile)

Having said all that, I think that writing plugins for IDE may be real fun.
It's challenging, educating, creative and most of all you can relatively fast achieve things of great values for developers by taking advantage of existing powerful IDE frameworks.
And there is nothing more important for me than hundreds or thousands of developers who actively use your plugin and contribute ideas.

We have recently exceeded 2500 downloads (only for IDEA version) and believe that with growing Eclipse version, incoming improvements and great new features we will make much more developers happy.

0.2.0 version of the Eclipse plugin has been released.

This time we added standard Eclipse notification about background plugin activities like retrieving list of plans, status of builds, etc.

You can also find new features in config dialog:

  • List of plans available for defined server so you can just easily select which ones you would like to watch. Favorite plans from your Bamboo server are marked with yellow star.
  • Refresh button which lets you retrieve list of plans using server's data entered into the form instead of data saved in configuration
  • Test Connection button which allows you to instantly test whether the server data is correct or not 

That release was the first one we built automatically using maven with ant script inside. Unfortunately the side effect is that your plugin configuration is empty after update. To retrieve the old one just change your old configuration file name from atlassian_eclipse_plugin.prefs to atlassian-eclipse-plugin.prefs

We also started work on handling multiple bamboo servers and labeling/commenting builds. I hope those features will be available in the next version in two weeks as well as using bamboo favorite builds.

Release notes will be available at


What you can expect

Here's a short list of things that will be implemented over next days, weeks and months. Just to let you know what we are working and thinking about.

So in this iteration (due in a week):

Atlassian IDEA Plugin will (here's a full list):

  • accept untrusted SSL certificates,
  • have NullPointerException, that occurs sometimes when project is loading, removed,
  • JIRA viewer will have clickable links in description,

Atlassian Eclipse Plugin will (here's a full list):

  • support more than one Bamboo server!,
  • show you list of Bamboo plans configured on server, with your favourites too!,
  • have an improved nofitication when Bamboo plans list is reloaded,

But that's not the most important thing I wanted to share with you. Actually that was only an introduction to the second topic - future. So what you can expect?

We're working hard to make Crucible support a state of the art. As of Crucible 1.6, which will be released in July/August, it will be possible to do a lot of new things from your IDE - we are silently working on improving Crucible's remote API and this will allow us to fully support pre and post-commit reviews in your IDE. You'll be able to follow whole Crucible workflow from within your IDE - create a review, comment it, and close. No other code review product will have such a good IDE integration.

As of Eclipse version we are trying to follow IDEA version (so you can expect the same support for Bamboo). We don't want to duplicate stuff that's already available in Mylyn, so we're not going to work on JIRA support. We are also thinking about enhancing Mylyn with additional features - there's an idea of making Crucible reviews a task in Mylyn, what do you think of it? As you know we just finished the second iteration, so we are still investigating available opportunities.

So this is a short summary, if you have any feedback please share! (smile)

Eclipse snapshot site

Just wanted to let you know that if someone has a wish to test unstable releases for Eclipse now he/she can do it easily :-D

We just configured nightly releases - they will be executed during our normal automatic builds. They will be deployed to (to use them just add this as a remote site in Eclipse->Help->Software Updates->Find and Install).

So why would you want to use unstable software in your work? Well, we do as we want to test Eclipse plug-in all the time (it's called eating your own dog food (smile) .

But why you? Well, thanks to this you'll be able to see what's going to be implemented and released, so you can influence how we do things? Really - if you see that's something what we are implementing isn't what you'd expect just give us a hint - here in comments, on JIRA - (and for Eclipse).

Eclipse plugin 0.1.0

Version 0.1.0 of Atlassian Eclipse plugin has been released.

Release notes will be available at

 Current version allows to connect to a single Bamboo server, subscribe to several plans, see the results in Eclipse Bamboo view, rerun build, go to the build web page (double click the build row). It fires popup notification about builds (configurable) and allows to configure bamboo server polling time.

Few screenshots below:




First news!

Just a test page (yeah, a lamer thing to do (wink)

Soon, we'll start posting here details about Atlassian IDE Plugin development.

Kind regards,

The Plugin Team

  • No labels

1 Comment

  1. Why I can't see IntelliJ's Connector's Roadmap?

Write a comment…