package org.apache.axis2.maven2.wsdl2code;
/*
* Copyright 2006 Apache Software Foundation.
*
* Licensed 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.
*/
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.axis2.util.CommandLineOption;
import org.apache.axis2.util.CommandLineOptionConstants;
import org.apache.axis2.util.CommandLineOptionParser;
import org.apache.axis2.wsdl.codegen.CodeGenerationEngine;
import org.apache.axis2.wsdl.codegen.CodeGenerationException;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.project.MavenProject;
/**
* @description A Mojo for generating Java sources from a WSDL.
* @goal wsdl2code
* @phase generate-sources
* @requiresDependencyResolution test
*/
public class WSDL2CodeMojo extends AbstractMojo
{
/**
* The maven project.
* @parameter expression="${project}"
* @read-only
* @required
*/
private MavenProject project;
/**
* The artifact factory.
* @parameter expression="${component.org.apache.maven.artifact.factory.ArtifactFactory}"
* @read-only
* @required
*/
private ArtifactFactory artifactFactory;
/**
* The plugins artifact list.
* @parameter expression="${plugin.artifacts}"
* @read-only
* @required
*/
private List pluginArtifacts;
/**
* The WSDL file, which is being read.
* @parameter expression="${axis2.wsdl2code.wsdl}" default-value="src/main/axis2/service.wsdl"
*/
private File wsdlFile;
/**
* The output directory, where the generated sources are being created.
* @parameter expression="${axis2.wsdl2code.target}" default-value="${project.build.directory}/generated-sources/axis2/wsdl2code"
*/
private File outputDirectory;
/**
* Package name of the generated sources; will be used to create a package structure
* below the output directory.
* @parameter expression="${axis2.wsdl2code.package}"
* @required
*/
private String packageName;
/**
* The programming language of the generated sources.
* @parameter expression="${axis2.wsdl2code.language}" default-value="java"
*/
private String language;
/**
* The databinding framework, which is being used.
* @parameter expression="${axis2.wsdl2code.databindingName}" default-value="adb"
*/
private String databindingName;
/**
* Port name, for which to generate sources. By default, sources will
* be generated for all ports.
* @parameter expression="${axis2.wsdl2code.portName}"
*/
private String portName;
/**
* Service name, for which to generate sources. By default, sources will
* be generated for all services.
* @parameter expression="${axis2.wsdl2code.serviceName}"
*/
private String serviceName;
/**
* Mode, for which sources are being generated; either of "sync", "async" or "both".
* @parameter expression="${axis2.wsdl2code.syncMode}" default-value="both"
*/
private String syncMode;
/**
* Whether server side sources are being generated.
* @parameter expression="${axis2.wsdl2code.generateServerSide}" default-value="false"
*/
private boolean generateServerSide;
/**
* Whether to generate sources for a test case.
* @parameter expression="${axis2.wsdl2code.generateTestCase}" default-value="false"
*/
private boolean generateTestcase;
/**
* Whether to generate a "services.xml" file.
* @parameter expression="${axis2.wsdl2code.generateServicesXml}" default-value="false"
*/
private boolean generateServicesXml;
/**
* Whether to generate simply all classes. This is only valid in conjunction with
* "generateServerSide".
* @parameter expression="${axis2.wsdl2code.generateAllClasses}" default-value="false"
*/
private boolean generateAllClasses;
/**
* Whether to unpack classes.
* @parameter expression="${axis2.wsdl2code.unpackClasses}" default-value="false"
*/
private boolean unpackClasses;
/**
* Whether to generate the server side interface.
* @parameter expression="${axis2.wsdl2code.generateServerSideInterface}" default-value="false"
*/
private boolean generateServerSideInterface = false;
/**
* @parameter expression="${axis2.wsdl2code.namespaceToPackages}"
*/
private String namespaceToPackages = null;
/**
* @parameter
*/
private NamespaceURIMapping[] namespaceURIs;
private static class InheritedArtifact
{
private final String groupId, artifactId;
private boolean added;
InheritedArtifact( String pGroupId, String pArtifactId )
{
groupId = pGroupId;
artifactId = pArtifactId;
}
String getGroupId() { return groupId; }
String getArtifactId() { return artifactId; }
boolean isAdded() { return added; }
void setAdded() {
if (added)
{
throw new IllegalStateException( "This artifact was already added: " +
groupId + ":" + artifactId );
}
}
}
private static final InheritedArtifact[] inheritedArtifacts =
{
new InheritedArtifact( "org.apache.axis2", "axis2-common" ),
new InheritedArtifact( "org.apache.axis2", "axis2-core" ),
new InheritedArtifact( "org.apache.ws.commons.axiom", "axiom-api" ),
new InheritedArtifact( "org.apache.ws.commons.axiom", "axiom-impl" ),
new InheritedArtifact( "org.apache.ws.commons", "neethi" ),
new InheritedArtifact( "wsdl4j", "wsdl4j" ),
new InheritedArtifact( "commons-httpclient", "commons-httpclient" )
};
private static final InheritedArtifact[] adbArtifacts =
{
new InheritedArtifact( "org.apache.axis2", "axis2-adb" )
};
/**
* Fills the option map. This map is passed onto
* the code generation API to generate the code.
*/
private Map fillOptionMap() throws MojoFailureException {
Map optionMap = new HashMap();
////////////////////////////////////////////////////////////////
//WSDL file name
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.WSDL_LOCATION_URI_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.WSDL_LOCATION_URI_OPTION,
getStringArray(wsdlFile.getPath())));
//output location
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.OUTPUT_LOCATION_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.OUTPUT_LOCATION_OPTION,
getStringArray(outputDirectory.getPath())));
//////////////////////////////////////////////////////////////////
// Databinding type
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.DATA_BINDING_TYPE_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.DATA_BINDING_TYPE_OPTION,
getStringArray(databindingName)));
if ("async".equals(syncMode)) {
// Async only option - forcing to generate async methods only
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.CODEGEN_ASYNC_ONLY_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.CODEGEN_ASYNC_ONLY_OPTION,
new String[0]));
} else if ("sync".equals(syncMode)) {
// Sync only option - forcing to generate Sync methods only
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.CODEGEN_SYNC_ONLY_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.CODEGEN_SYNC_ONLY_OPTION,
new String[0]));
} else if ("both".equals(syncMode)) {
// Do nothing
} else {
throw new MojoFailureException("Invalid syncMode: " + syncMode +
", expected either of 'sync', 'async' or 'both'.");
}
//Package
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.PACKAGE_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.PACKAGE_OPTION,
getStringArray(packageName)));
//stub language
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.STUB_LANGUAGE_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.STUB_LANGUAGE_OPTION,
getStringArray(language)));
//server side and generate services.xml options
if (generateServerSide) {
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.SERVER_SIDE_CODE_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.SERVER_SIDE_CODE_OPTION,
new String[0]));
//services XML generation - effective only when specified as the server side
if (generateServicesXml) {
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants
.GENERATE_SERVICE_DESCRIPTION_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants
.GENERATE_SERVICE_DESCRIPTION_OPTION,
new String[0]));
}
//generate all option - Only valid when generating serverside code
if (generateAllClasses) {
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.GENERATE_ALL_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.GENERATE_ALL_OPTION,
new String[0]));
}
}
//generate the test case
if (generateTestcase) {
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.GENERATE_TEST_CASE_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.GENERATE_TEST_CASE_OPTION,
new String[0]));
}
//Unwrap classes option - this determines whether the generated classes are inside the stub/MR
//or gets generates as seperate classes
if (unpackClasses) {
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.UNPACK_CLASSES_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.UNPACK_CLASSES_OPTION,
new String[0]));
}
//server side interface option
if (generateServerSideInterface) {
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.SERVER_SIDE_INTERFACE_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.SERVER_SIDE_INTERFACE_OPTION,
new String[0]));
}
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.SERVICE_NAME_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.SERVICE_NAME_OPTION,
new String[]{serviceName}));
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.PORT_NAME_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.PORT_NAME_OPTION,
new String[]{portName}));
// set the namespaces
optionMap.put(
CommandLineOptionConstants.WSDL2JavaConstants.NAME_SPACE_TO_PACKAGE_OPTION,
new CommandLineOption(
CommandLineOptionConstants.WSDL2JavaConstants.NAME_SPACE_TO_PACKAGE_OPTION,
new String[]{getNamespaceToPackagesMap()}));
return optionMap;
}
private String getNamespaceToPackagesMap() throws MojoFailureException {
StringBuffer sb = new StringBuffer();
if (namespaceToPackages != null) {
sb.append(namespaceToPackages);
}
if (namespaceURIs != null) {
for (int i = 0; i < namespaceURIs.length; i++) {
NamespaceURIMapping mapping = namespaceURIs[i];
String uri = mapping.getUri();
if (uri == null) {
throw new MojoFailureException("A namespace to package mapping requires an uri child element.");
}
String uriPackageName = mapping.getPackageName();
if (uriPackageName != null) {
throw new MojoFailureException("A namespace to package mapping requires a packageName child element.");
}
if(sb.length() > 0) {
sb.append(",");
}
sb.append(uri);
sb.append('=');
sb.append(uriPackageName);
}
}
return sb.toString();
}
/**
* Utility method to convert a string into a single item string[]
* @param value
* @return Returns String[].
*/
private String[] getStringArray(String value) {
String[] values = new String[1];
values[0] = value;
return values;
}
public void execute() throws MojoFailureException, MojoExecutionException {
Map commandLineOptions = this.fillOptionMap();
CommandLineOptionParser parser =
new CommandLineOptionParser(commandLineOptions);
try {
new CodeGenerationEngine(parser).generate();
} catch (CodeGenerationException e) {
Throwable t = e;
while (t.getCause() != null)
{
t = t.getCause();
}
t.printStackTrace();
throw new MojoExecutionException(e.getMessage(), e);
}
fixCompileSourceRoots();
fixDependencies();
showDependencies();
}
private void showDependencies()
{
Log log = getLog();
if ( !log.isDebugEnabled() )
{
return;
}
log.debug( "The projects dependency artifacts are: " );
for (Iterator iter = project.getDependencyArtifacts().iterator(); iter.hasNext(); )
{
Artifact artifact = (Artifact) iter.next();
log.debug( " " + artifact.getGroupId() + ":" + artifact.getArtifactId() +
":" + artifact.getVersion() + ":" + artifact.getClassifier() +
":" + artifact.getScope() + ":" + artifact.getType() );
}
log.debug( "The projects transitive artifacts are: " );
for (Iterator iter = project.getArtifacts().iterator(); iter.hasNext(); )
{
Artifact artifact = (Artifact) iter.next();
log.debug( " " + artifact.getGroupId() + ":" + artifact.getArtifactId() +
":" + artifact.getVersion() + ":" + artifact.getClassifier() +
":" + artifact.getScope() + ":" + artifact.getType() );
}
}
private Artifact findArtifact(Collection pCollection, String pGroupId, String pArtifactId) {
for ( Iterator iter = pCollection.iterator(); iter.hasNext(); )
{
Artifact artifact = (Artifact) iter.next();
if ( pGroupId.equals( artifact.getGroupId() ) &&
pArtifactId.equals( artifact.getArtifactId() ) )
{
return artifact;
}
}
return null;
}
private InheritedArtifact[] getInheritedArtifacts()
{
final List list = new ArrayList();
list.addAll( Arrays.asList( inheritedArtifacts ) );
if ( "adb".equals( databindingName ) ) {
list.addAll( Arrays.asList( adbArtifacts ) );
}
return (InheritedArtifact[]) list.toArray( new InheritedArtifact[ list.size() ] );
}
private InheritedArtifact getInheritedArtifact( InheritedArtifact[] pInheritedArtifacts,
Artifact pArtifact )
{
for ( int i = 0; i < pInheritedArtifacts.length; i++ )
{
InheritedArtifact iArtifact = pInheritedArtifacts[i];
if ( iArtifact.getGroupId().equals( pArtifact.getGroupId() ) &&
iArtifact.getArtifactId().equals( pArtifact.getArtifactId() ) )
{
return iArtifact;
}
}
return null;
}
private void fixDependencies()
{
final Set set = new HashSet( project.getDependencyArtifacts() );
final InheritedArtifact[] inhArtifacts = getInheritedArtifacts();
for (Iterator iter = pluginArtifacts.iterator(); iter.hasNext(); )
{
final Artifact artifact = (Artifact) iter.next();
final InheritedArtifact iArtifact = getInheritedArtifact( inhArtifacts, artifact );
if ( iArtifact != null )
{
iArtifact.setAdded();
final String groupId = artifact.getGroupId();
final String artifactId = artifact.getArtifactId();
if ( findArtifact( project.getArtifacts(), groupId, artifactId )
== null)
{
getLog().debug( "Adding artifact " + groupId + ":" + artifactId );
Artifact artfct = artifactFactory.createArtifactWithClassifier( groupId, artifactId,
artifact.getVersion(),
artifact.getType(),
artifact.getClassifier() );
artfct.setScope( Artifact.SCOPE_COMPILE );
set.add( artfct );
}
else
{
getLog().debug( "The artifact " + artifact.getGroupId() + ":" +
artifact.getArtifactId() + " is already present " +
" in the project and will not be added." );
}
}
}
project.setDependencyArtifacts( set );
}
private void fixCompileSourceRoots()
{
File srcDir = new File(outputDirectory, "src");
project.addCompileSourceRoot(srcDir.getPath());
}
}