/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.maven.plugin.jira;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.MappingJsonFactory;
import org.apache.cxf.configuration.security.AuthorizationPolicy;
import org.apache.cxf.configuration.security.ProxyAuthorizationPolicy;
import org.apache.cxf.interceptor.LoggingInInterceptor;
import org.apache.cxf.interceptor.LoggingOutInterceptor;
import org.apache.cxf.jaxrs.client.ClientConfiguration;
import org.apache.cxf.jaxrs.client.WebClient;
import org.apache.cxf.transport.http.HTTPConduit;
import org.apache.cxf.transports.http.configuration.HTTPClientPolicy;
import org.apache.cxf.transports.http.configuration.ProxyServerType;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugin.issues.Issue;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* Use the JIRA REST API to implement the download.
*
* This class assumes that the URL points to a copy of JIRA that implements the REST API.
* A static function may be forthcoming in here to probe and see if a given URL supports it.
*
*/
public class RestJiraDownloader extends AbstractJiraDownloader
{
private List<Issue> issueList;
private JsonFactory jsonFactory;
private SimpleDateFormat dateFormat;
private List<String> resolvedFixVersionIds;
private List<String> resolvedStatusIds;
private List<String> resolvedComponentIds;
private List<String> resolvedTypeIds;
private List<String> resolvedResolutionIds;
private List<String> resolvedPriorityIds;
private String jiraProject;
public static class NoRest extends Exception {
public NoRest( )
{
// blank on purpose.
}
public NoRest( String message )
{
super( message );
}
}
public RestJiraDownloader() {
jsonFactory = new MappingJsonFactory( );
//2012-07-17T06:26:47.723-0500
dateFormat = new SimpleDateFormat( "yyyy-MM-dd'T'HH:mm:ss.SSSZ" );
resolvedFixVersionIds = new ArrayList<String>( );
resolvedStatusIds = new ArrayList<String>( );
resolvedComponentIds = new ArrayList<String>( );
resolvedTypeIds = new ArrayList<String>( );
resolvedResolutionIds = new ArrayList<String>( );
resolvedPriorityIds = new ArrayList<String>( );
}
public void doExecute()
throws Exception
{
Map<String, String> urlMap = JiraHelper.getJiraUrlAndProjectName( project.getIssueManagement().getUrl() );
String jiraUrl = urlMap.get( "url" );
jiraProject = urlMap.get( "project" );
// This classloader juggling is a workaround for a classic Maven 2 class loader management bug.
ClassLoader ccl = Thread.currentThread().getContextClassLoader();
try
{
Thread.currentThread().setContextClassLoader( WebClient.class.getClassLoader( ) );
WebClient client = setupWebClient( jiraUrl );
// We use version 2 of the REST API, that first appeared in JIRA 5
// Check if version 2 of the REST API is supported
// http://docs.atlassian.com/jira/REST/5.0/
// Note that serverInfo can always be accessed without authentication
client.replacePath( "/rest/api/2/serverInfo" );
client.accept( MediaType.APPLICATION_JSON );
Response siResponse = client.get();
if ( siResponse.getStatus() != Response.Status.OK.getStatusCode() )
{
throw new NoRest(
"This JIRA server does not support version 2 of the REST API, which maven-changes-plugin requires." );
}
doSessionAuth( client );
resolveIds( client, jiraProject );
String jqlQuery = new JqlQueryBuilder( log ).urlEncode( false ).project( jiraProject ).fixVersion(
getFixFor() ).fixVersionIds( resolvedFixVersionIds ).statusIds( resolvedStatusIds ).priorityIds(
resolvedPriorityIds ).resolutionIds( resolvedResolutionIds ).components( resolvedComponentIds ).typeIds(
resolvedTypeIds ).sortColumnNames( sortColumnNames ).build();
StringWriter searchParamStringWriter = new StringWriter();
JsonGenerator gen = jsonFactory.createGenerator( searchParamStringWriter );
gen.writeStartObject();
gen.writeStringField( "jql", jqlQuery );
gen.writeNumberField( "maxResults", nbEntriesMax );
gen.writeArrayFieldStart( "fields" );
// Retrieve all fields. If that seems slow, we can reconsider.
gen.writeString( "*all" );
gen.writeEndArray();
gen.writeEndObject();
gen.close();
client.replacePath( "/rest/api/2/search" );
client.type( MediaType.APPLICATION_JSON_TYPE );
client.accept( MediaType.APPLICATION_JSON_TYPE );
Response searchResponse = client.post( searchParamStringWriter.toString() );
if ( searchResponse.getStatus() != Response.Status.OK.getStatusCode() )
{
reportErrors( searchResponse );
}
JsonNode issueTree = getResponseTree( searchResponse );
assert issueTree.isObject();
JsonNode issuesNode = issueTree.get( "issues" );
assert issuesNode.isArray();
buildIssues( issuesNode, jiraUrl, jiraProject );
}
finally
{
Thread.currentThread().setContextClassLoader( ccl );
}
}
private JsonNode getResponseTree( Response response )
throws IOException
{
JsonParser jsonParser = jsonFactory.createJsonParser( (InputStream) response.getEntity() );
return (JsonNode) jsonParser.readValueAsTree();
}
private void reportErrors( Response resp )
throws IOException, MojoExecutionException
{
if ( MediaType.APPLICATION_JSON_TYPE.getType().equals( getResponseMediaType( resp ).getType() ) )
{
JsonNode errorTree = getResponseTree( resp );
assert errorTree.isObject();
JsonNode messages = errorTree.get( "errorMessages" );
if ( messages != null )
{
for ( int mx = 0; mx < messages.size(); mx ++ )
{
getLog().error( messages.get( mx ).asText() );
}
}
else
{
JsonNode message = errorTree.get( "message" );
if ( message != null )
{
getLog().error( message.asText() );
}
}
}
throw new MojoExecutionException( String.format( "Failed to query issues; response %d", resp.getStatus() ) );
}
private void resolveIds( WebClient client, String jiraProject )
throws IOException, MojoExecutionException, MojoFailureException
{
resolveList( resolvedComponentIds, client, "components", component, "/rest/api/2/project/{key}/components", jiraProject );
resolveList( resolvedFixVersionIds, client, "fixVersions", fixVersionIds, "/rest/api/2/project/{key}/versions", jiraProject );
resolveList( resolvedStatusIds, client, "status", statusIds, "/rest/api/2/status" );
resolveList( resolvedResolutionIds, client, "resolution", resolutionIds, "/rest/api/2/resolution" );
resolveList( resolvedTypeIds, client, "type", typeIds, "/rest/api/2/issuetype" );
resolveList( resolvedPriorityIds, client, "priority", priorityIds, "/rest/api/2/priority" );
}
private void resolveList( List<String> targetList, WebClient client, String what, String input,
String listRestUrlPattern, String... listUrlArgs )
throws IOException, MojoExecutionException, MojoFailureException
{
if ( input == null || input.length() == 0 )
{
return;
}
if ( listUrlArgs != null && listUrlArgs.length != 0)
{
client.replacePath( "/" );
client.path( listRestUrlPattern, listUrlArgs );
}
else
{
client.replacePath( listRestUrlPattern );
}
client.accept( MediaType.APPLICATION_JSON );
Response resp = client.get();
if ( resp.getStatus() != 200 )
{
getLog().error( String.format( "Could not get %s list from %s", what, listRestUrlPattern ) );
reportErrors( resp );
}
JsonNode items = getResponseTree( resp );
String[] pieces = input.split( "," );
for (String item : pieces ) {
targetList.add( resolveOneItem( items, what, item ) );
}
}
private String resolveOneItem( JsonNode items, String what, String nameOrId )
throws IOException, MojoExecutionException, MojoFailureException
{
for ( int cx = 0; cx < items.size(); cx ++ )
{
JsonNode item = items.get( cx );
if ( nameOrId.equals( item.get( "id" ).asText() ) )
{
return nameOrId;
}
else if ( nameOrId.equals( item.get( "name" ).asText() ) )
{
return item.get( "id" ).asText();
}
}
throw new MojoFailureException( String.format("Could not find %s %s.", what, nameOrId ) );
}
private MediaType getResponseMediaType( Response response )
{
String header = (String) response.getMetadata().getFirst( HttpHeaders.CONTENT_TYPE ) ;
return header == null ? null : MediaType.valueOf( header );
}
private void buildIssues( JsonNode issuesNode, String jiraUrl, String jiraProject )
{
issueList = new ArrayList<Issue>( );
for ( int ix = 0; ix < issuesNode.size(); ix++ )
{
JsonNode issueNode = issuesNode.get( ix );
assert issueNode.isObject();
Issue issue = new Issue();
JsonNode val;
val = issueNode.get( "id" );
if ( val != null )
{
issue.setId( val.asText() );
}
val = issueNode.get( "key" );
if ( val != null )
{
issue.setKey( val.asText() );
issue.setLink( String.format( "%s/browse/%s", jiraUrl, val.asText()) );
}
// much of what we want is in here.
JsonNode fieldsNode = issueNode.get( "fields" );
val = fieldsNode.get( "assignee" );
processAssignee( issue, val );
val = fieldsNode.get( "created" );
processCreated( issue, val );
val = fieldsNode.get( "comment" );
processComments( issue, val );
val = fieldsNode.get( "fixVersions" );
processFixVersions( issue, val );
val = fieldsNode.get( "priority" );
processPriority( issue, val );
val = fieldsNode.get( "reporter" );
processReporter( issue, val );
val = fieldsNode.get( "resolution" );
processResolution( issue, val );
val = fieldsNode.get( "status" );
processStatus( issue, val );
val = fieldsNode.get( "summary" );
if ( val != null )
{
issue.setSummary( val.asText() );
}
val = issueNode.get( "title" );
if ( val != null )
{
issue.setTitle( val.asText() );
}
val = issueNode.get( "updated" );
processUpdated( issue, val );
val = issueNode.get( "versions" );
processVersions( issue, val );
issueList.add( issue );
}
}
private void processVersions( Issue issue, JsonNode val )
{
StringBuilder sb = new StringBuilder( );
if ( val != null )
{
for ( int vx = 0; vx < val.size(); vx ++ )
{
sb.append( val.get( vx ).get( "name" ).asText() );
sb.append( ", " );
}
}
if ( sb.length() > 0 )
{
// remove last ", "
issue.setVersion( sb.substring( 0, sb.length() - 2 ) );
}
}
private void processStatus( Issue issue, JsonNode val )
{
if (val != null )
{
issue.setStatus( val.get( "name" ).asText() );
}
}
private void processPriority( Issue issue, JsonNode val )
{
if (val != null )
{
issue.setPriority( val.get( "name" ).asText() );
}
}
private void processResolution( Issue issue, JsonNode val )
{
if (val != null )
{
issue.setResolution( val.get( "name" ).asText() );
}
}
private String getPerson( JsonNode val )
{
JsonNode nameNode = val.get( "displayName" );
if ( nameNode == null )
{
nameNode = val.get( "name" );
}
if ( nameNode != null )
{
return nameNode.asText();
}
else
{
return null;
}
}
private void processAssignee( Issue issue, JsonNode val )
{
if ( val != null )
{
String text = getPerson( val );
if ( text != null )
{
issue.setAssignee( text );
}
}
}
private void processReporter( Issue issue, JsonNode val )
{
if ( val != null )
{
String text = getPerson( val );
if ( text != null )
{
issue.setReporter( text );
}
}
}
private void processCreated( Issue issue, JsonNode val )
{
if ( val != null )
{
try
{
issue.setCreated( parseDate( val ) );
}
catch ( ParseException e )
{
getLog().warn( "Invalid created date " + val.asText() );
}
}
}
private void processUpdated( Issue issue, JsonNode val )
{
if ( val != null )
{
try
{
issue.setUpdated( parseDate( val ) );
}
catch ( ParseException e )
{
getLog().warn( "Invalid created date " + val.asText() );
}
}
}
private Date parseDate( JsonNode val )
throws ParseException
{
return dateFormat.parse( val.asText() );
}
private void processFixVersions( Issue issue, JsonNode val )
{
if (val != null)
{
assert val.isArray();
for ( int vx = 0; vx < val.size(); vx++ )
{
JsonNode fvNode = val.get( vx );
issue.addFixVersion( fvNode.get( "name" ).asText() );
}
}
}
private void processComments( Issue issue, JsonNode val )
{
if ( val != null )
{
JsonNode commentsArray = val.get( "comments" );
for ( int cx = 0; cx < commentsArray.size(); cx++ )
{
JsonNode cnode = commentsArray.get( cx );
issue.addComment( cnode.get( "body" ).asText() );
}
}
}
private void doSessionAuth( WebClient client )
throws IOException, MojoExecutionException, NoRest
{
/* if JiraUser is specified instead of WebUser, we need to make a session. */
if ( jiraUser != null )
{
client.replacePath( "/rest/auth/1/session" );
client.type( MediaType.APPLICATION_JSON_TYPE );
StringWriter jsWriter = new StringWriter( );
JsonGenerator gen = jsonFactory.createGenerator( jsWriter );
gen.writeStartObject();
gen.writeStringField( "username", jiraUser );
gen.writeStringField( "password", jiraPassword );
gen.writeEndObject();
gen.close();
Response authRes = client.post( jsWriter.toString() );
if ( authRes.getStatus() != Response.Status.OK.getStatusCode() )
{
if ( authRes.getStatus() != 401 && authRes.getStatus() != 403 )
{
// if not one of the documented failures, assume that there's no rest in there in the first place.
throw new NoRest();
}
throw new MojoExecutionException( String.format( "Authentication failure status %d.", authRes.getStatus() ) );
}
}
}
private WebClient setupWebClient( String jiraUrl )
{
WebClient client = WebClient.create( jiraUrl );
ClientConfiguration clientConfiguration = WebClient.getConfig( client );
HTTPConduit http = clientConfiguration.getHttpConduit();
if ( getLog().isDebugEnabled() )
{
clientConfiguration.getInInterceptors().add( new LoggingInInterceptor( ) );
clientConfiguration.getOutInterceptors().add( new LoggingOutInterceptor( ) );
}
HTTPClientPolicy httpClientPolicy = new HTTPClientPolicy();
httpClientPolicy.setConnectionTimeout(36000);
httpClientPolicy.setAllowChunking(false);
httpClientPolicy.setReceiveTimeout(32000);
if ( proxyHost != null )
{
getLog().debug( "Using proxy: " + proxyHost + " at port " + proxyPort );
httpClientPolicy.setProxyServer( proxyHost );
httpClientPolicy.setProxyServerPort( proxyPort );
httpClientPolicy.setProxyServerType( ProxyServerType.HTTP );
if ( proxyUser != null )
{
ProxyAuthorizationPolicy proxyAuthorizationPolicy = new ProxyAuthorizationPolicy();
proxyAuthorizationPolicy.setAuthorizationType( "Basic" );
proxyAuthorizationPolicy.setUserName( proxyUser );
proxyAuthorizationPolicy.setPassword( proxyPass );
http.setProxyAuthorization( proxyAuthorizationPolicy );
}
}
if ( webUser != null )
{
AuthorizationPolicy authPolicy = new AuthorizationPolicy();
authPolicy.setAuthorizationType( "Basic" );
authPolicy.setUserName( webUser );
authPolicy.setPassword( webPassword );
http.setAuthorization( authPolicy );
}
http.setClient(httpClientPolicy);
return client;
}
public List<Issue> getIssueList() throws MojoExecutionException
{
return issueList;
}
}