When implementing complex plug-ins for the Atlassian suite, it might be needed to request information from another Atlassian application. You can see examples for it, when JIRA shows Stash commits, of Confluence pages.
As all Atlassian applications has a REST API, it is possible to make JSON calls directly. Using Application Links for communication between Atlassian products however has following advantages
- It uses central authentication of the Atlassian applications. You can take advantage of the centralized CROWD user management, and don't need to store user and password in some configuration of your plug-in. You also don't need to set authentication data in your code.
- You use components of the common com.atlassian.applinks.api package, and it is part of the core features of all Atlassian applications. All needed components are included in com.atlassian.applinks maven group, which is automatically included by the application. Therefore you do not need to add any additional maven dependencies to your project.
- As application liking is supported by all Atlassian products, you can reach all of them with a single programming API from your add-on.
Disadvantage of the solution is, that you are working with pure JSON responses, so in order to map them into the Java world, you need a mapping framework (like Jackson or Gson), and most probably implement your own classes holding the returned information.
If you want to use a single application, with a more object oriented way, you can consider using product specific API.s like JiraRestClient from the com.atlassian.jira.rest.client.api package.
Configuring Application link
In order to use functionalities of JIRA from my Confluence plug-in, I have created an Application link between the two servers. In local development environment I had to configure the link to use the "Trusted application" authentication type, in order to get it worked.
I made the following steps to create the application link
- Start the JIRA and the Confluence server locally, using the atlassian-run command in the root directory of the plug-ins.
- Log in as admin to both applications
- In JIRA navigate to Administration/Applications/Application links
- Create a new application link following the wizard. The process includes to go to the Confluence administration page and set the inverse link as well.
- After the application links are visible on both of the servers, set the authentication for incoming and outgoing link to "OAuth (impersonation)" everywhere.
Doing so, you configures trusted application connection, and you do not need to bother with authentication in the plug-in code.
Implementing usage of Application link
I have implemented an example to show, how to get a list of all JIRA fields in Confluence using the application link to JIRA.
The result from JIRA looks like this:
[
{"id":"issuetype","name":"Issue Type","custom":false,"orderable":true,
"navigable":true,"searchable":true,"clauseNames":["issuetype","type"],
"schema":{"type":"issuetype","system":"issuetype"}},
{"id":"components","name":"Component/s","custom":false,"orderable":true,
"navigable":true,"searchable":true,"clauseNames":["component"],
"schema":{"type":"array","items":"component","system":"components"}}, ...
At the first step, I create an
ApplicationLinkRequest pointing to the given URL.
final static int APP_LINK_TIME_OUT = 60000;
// Logger instance
private static final Logger log = LoggerFactory.getLogger(JiraServiceCaller.class);
@Autowired
private ApplicationLinkService appLinkService;
/**
* Creates ApplicationLinkRequest for calling JIRA REST service, based on the restServiceUrl parameter.
*
* @param restServiceUrl
* @return
*/
protected ApplicationLinkRequest createApplicationLinkRequest(String restServiceUrl) {
MethodType methodType = Request.MethodType.POST;
ApplicationLinkRequest aplrq = createApplicationLinkRequest(restServiceUrl, methodType);
return aplrq;
}
private ApplicationLinkRequest createApplicationLinkRequest(String restServiceUrl, MethodType methodType) {
ApplicationLink appLink = appLinkService.getPrimaryApplicationLink(JiraApplicationType.class);
if (appLink == null) {
log.info("Failed to handle REST request. CredentialsRequiredException occured.");
throw new JiraConnectionException("Unable to get application link of type 'JiraApplication'");
}
ApplicationLinkRequestFactory factory = appLink.createAuthenticatedRequestFactory();
ApplicationLinkRequest aplrq = null;
try {
aplrq = factory.createRequest(methodType, appLink.getRpcUrl() + restServiceUrl);
aplrq.setSoTimeout(APP_LINK_TIME_OUT);
} catch (CredentialsRequiredException e) {
log.warn("Error while creating ApplicationLinkRequest", e);
throw new JiraConnectionException("Unable to connect JIRA via application link. Error message: '" + e.getMessage() + "'");
}
return aplrq;
}
Than I execute the configured
ApplicationLinkRequest to get the result of the REST API call.
private static final String REST_JIRA_RETRIEVE_FIELDS = "/rest/api/2/field";
/**
* Retrieves a list containing name of all existing JIRA fields
*/
@Override
public List<String> retrieveFieldNames() {
List<String> result = new ArrayList<String>();
try {
ApplicationLinkRequest alr = createApplicationLinkGetRequest(REST_JIRA_RETRIEVE_FIELDS);
String jiraResponse = alr.execute();
if (StringUtils.isNotBlank(jiraResponse)) {
ObjectMapper mapper = new ObjectMapper();
JsonJiraField[] myObjects = mapper.readValue(jiraResponse, JsonJiraField[].class);
for (int i = 0; i < myObjects.length; i++) {
JsonJiraField jsonJiraField = myObjects[i];
result.add(jsonJiraField.getName());
}
}
} catch (IOException | ResponseException e) {
log.warn("Failed to handle REST request. IOException occured.", e.getMessage());
}
return result;
}
For mapping between the JSON sting and the Java code, I implemented a simple value object, holding the JIRA field info, and used the
ObjectMapper from Jackson to fill it up with data.
Add parameters to the REST call
The
ApplicationLinkRequest makes it possible to add parameters to your REST call as key - value pairs, like this:
alr.addRequestParameters("projectKey", projectKey);
