下面列出了怎么用org.apache.maven.plugin.MojoExecutionException的API类实例代码及写法,或者点击链接到github查看源代码。
public void execute()
throws MojoExecutionException
{
if (skip || skipDependencyBuild) {
getLog().info("Skip dependency build");
return;
}
for (String inputDirectory : getChartDirectories(getChartDirectory())) {
getLog().info("Build chart dependencies for " + inputDirectory + "...");
callCli(getHelmExecuteablePath()
+ " dependency build "
+ inputDirectory
+ (StringUtils.isNotEmpty(getRegistryConfig()) ? " --registry-config=" + getRegistryConfig() : "")
+ (StringUtils.isNotEmpty(getRepositoryCache()) ? " --repository-cache=" + getRepositoryCache() : "")
+ (StringUtils.isNotEmpty(getRepositoryConfig()) ? " --repository-config=" + getRepositoryConfig() : ""),
"Failed to resolve dependencies", true);
}
}
private WatchingException buildWatchingException(String stream, File file, MojoExecutionException e) {
String[] lines = stream.split("\n");
for (String l : lines) {
if (!Strings.isNullOrEmpty(l)) {
stream = l.trim();
break;
}
}
final Matcher matcher = LESS_ERROR_PATTERN.matcher(stream);
if (matcher.matches()) {
String line = matcher.group(2);
String character = matcher.group(3);
String reason = matcher.group(1);
return new WatchingException("Less Compilation Error", reason, file,
Integer.valueOf(line), Integer.valueOf(character), null);
} else {
return new WatchingException("Less Compilation Error", stream, file, e.getCause());
}
}
@Test
public void writeTokenFile_devModePropertiesAreWritten()
throws IOException, MojoExecutionException, MojoFailureException {
mojo.execute();
String json = org.apache.commons.io.FileUtils
.readFileToString(tokenFile, StandardCharsets.UTF_8);
JsonObject buildInfo = JsonUtil.parse(json);
Assert.assertTrue(
Constants.SERVLET_PARAMETER_ENABLE_PNPM
+ "should have been written",
buildInfo.getBoolean(Constants.SERVLET_PARAMETER_ENABLE_PNPM));
Assert.assertTrue(
Constants.REQUIRE_HOME_NODE_EXECUTABLE
+ "should have been written",
buildInfo.getBoolean(Constants.REQUIRE_HOME_NODE_EXECUTABLE));
Assert.assertFalse(buildInfo
.hasKey(Constants.SERVLET_PARAMETER_DEVMODE_OPTIMIZE_BUNDLE));
}
@Override
public void execute() throws MojoExecutionException {
checkMandatoryField(inputFileDirectory, "inputFileDirectory");
checkMandatoryField(outputFileDirectory, "outputFileDirectory");
this.getLog().info(String.format("Transforming '%s' to '%s' ...", this.inputFileDirectory, this.outputFileDirectory));
MavenBuildLogger logger = new MavenBuildLogger(this.getLog());
FileTransformer transformer = new RDFToDMNTransformer(
inputParameters,
logger
);
transformer.transform(inputFileDirectory.toPath(), outputFileDirectory.toPath());
try {
this.project.addCompileSourceRoot(this.outputFileDirectory.getCanonicalPath());
} catch (IOException e) {
throw new MojoExecutionException("", e);
}
}
/**
* Mock project with one image, query service indicates running image, and it is labelled.
* Removal should pass true for removeVolumes.
*
* @throws IOException
* @throws MojoExecutionException
* @throws ExecException
*/
@Test
public void stopWithSingleImageIsLabelledRemoveVolume() throws IOException, MojoExecutionException, ExecException {
givenProjectWithResolvedImage(singleImageWithBuild());
givenContainerIsRunningForImage("example:latest", "container-id", "example-1");
givenContainerHasGavLabels();
Deencapsulation.setField(stopMojo, "removeVolumes", true);
whenMojoExecutes();
thenContainerLookupByImageOccurs("example:latest");
thenListContainersIsNotCalled();
thenContainerIsStopped("container-id", false, true);
}
/**
* Parses the argument string given by the user. Strings are recognized as everything between STRING_WRAPPER.
* PARAMETER_DELIMITER is ignored inside a string. STRING_WRAPPER and PARAMETER_DELIMITER can be escaped using
* ESCAPE_CHAR.
*
* @return Array of String representing the arguments
* @throws MojoExecutionException for wrong formatted arguments
*/
protected String[] parseCommandlineArgs()
throws MojoExecutionException
{
if ( commandlineArgs == null )
{
return null;
}
else
{
try
{
return CommandLineUtils.translateCommandline( commandlineArgs );
}
catch ( Exception e )
{
throw new MojoExecutionException( e.getMessage() );
}
}
}
public static List<File> getWsdlFiles(File dir, String[] includes, String[] excludes)
throws MojoExecutionException {
List<String> exList = new ArrayList<>();
if (excludes != null) {
Collections.addAll(exList, excludes);
}
Collections.addAll(exList, org.codehaus.plexus.util.FileUtils.getDefaultExcludes());
String inc = joinWithComma(includes);
String ex = joinWithComma(exList.toArray(new String[0]));
try {
List<?> newfiles = org.codehaus.plexus.util.FileUtils.getFiles(dir, inc, ex);
return CastUtils.cast(newfiles);
} catch (IOException exc) {
throw new MojoExecutionException(exc.getMessage(), exc);
}
}
@Override
@SneakyThrows
public void execute() throws MojoExecutionException, MojoFailureException {
Context.builder()
.executionEnvironment(executionEnvironment(project, session, buildPluginManager))
.camundaVersion(camundaVersion)
.unpackDirectory(unpackDirectory)
.outputDirectory(outputDirectory)
.noClasspath(false)
.autoImports(false)
.shouldCompile(false)
.dtoYamlFile(dtoYamlFile)
.serviceYamlFile(serviceYamlFile)
.build()
.initDirectory()
.downloadSources()
.loadDtoDocumentation()
.loadServiceDocumentation()
.processSources()
;
}
/**
* Iterate through all the extensions dependencies declared in the project and
* collect all the runtime scope dependencies for inclusion in the .zip and just
* copy them to the lib directory.
* <p>
* TODO, should check that all dependencies are well signed with the same
* extension with the same signer.
*
* @throws MojoExecutionException TODO
*/
private void processExtensionsDependencies()
throws MojoExecutionException
{
Collection<Artifact> artifacts =
isExcludeTransitive() ? getProject().getDependencyArtifacts() : getProject().getArtifacts();
for ( JnlpExtension extension : jnlpExtensions )
{
ArtifactFilter filter = new IncludesArtifactFilter( extension.getIncludes() );
for ( Artifact artifact : artifacts )
{
if ( filter.include( artifact ) )
{
processExtensionDependency( extension, artifact );
}
}
}
}
@Override
public void execute() throws MojoExecutionException {
if ("war".equals(this.project.getPackaging())) {
getLog().debug("repackage goal could not be applied to war project.");
return;
}
if ("pom".equals(this.project.getPackaging())) {
getLog().debug("repackage goal could not be applied to pom project.");
return;
}
if (StringUtils.isSameStr(this.arkClassifier, this.bizClassifier)) {
getLog().debug("Executable fat jar should be different from 'plug-in' module jar.");
return;
}
if (this.skip) {
getLog().debug("skipping repackaging as configuration.");
return;
}
/* version of ark container packaged into fat jar follows the plugin version */
PluginDescriptor pluginDescriptor = (PluginDescriptor) getPluginContext().get(
"pluginDescriptor");
arkVersion = pluginDescriptor.getVersion();
repackage();
}
/**
* This will compute the vertx application id(s) that will be passed to the vertx applicaiton with "-id"
* option, if the appId is not found in the configuration an new {@link UUID} will be generated and assigned
*/
private void getAppId() throws MojoExecutionException {
if (appIds == null) {
appIds = new HashSet<>();
}
Path vertxPidFile = Paths.get(workDirectory.toString(), VERTX_PID_FILE);
if (Files.exists(vertxPidFile)) {
try {
byte[] bytes = Files.readAllBytes(vertxPidFile);
appIds.add(new String(bytes));
} catch (IOException e) {
throw new MojoExecutionException("Error reading " + VERTX_PID_FILE, e);
}
}
}
@Override
public final void execute() throws MojoExecutionException, MojoFailureException {
if (isSkipped()) {
getLog().info(Messages.AbstractSarlMojo_5);
return;
}
try {
this.mavenHelper = new MavenHelper(this.session, this.buildPluginManager, this.repositorySystem,
this.resolutionErrorHandler, getLog());
ensureDefaultParameterValues();
prepareExecution();
executeMojo();
} catch (Exception e) {
getLog().error(e.getLocalizedMessage(), e);
throw e;
}
}
@Test
public void testCustomArguments() throws MojoFailureException, MojoExecutionException, IOException {
cleanup();
less.execute();
mojo.cleanCssArguments = "--debug -c ie7 -b";
mojo.execute();
File site = new File(FAKE_PROJECT_TARGET, "classes/assets/css/site-min.css");
assertThat(site).isFile();
assertThat(FileUtils.readFileToString(site))
.contains("h1{color:red}");
File style = new File(FAKE_PROJECT_TARGET, "classes/assets/less/style-min.css");
assertThat(style).isFile();
assertThat(FileUtils.readLines(style)).hasSize(2); // We don't remove line break.
}
public void execute()
throws MojoExecutionException
{
if (skip || skipUpload) {
getLog().info("Skip upload");
return;
}
getLog().info("Uploading to " + getHelmUploadUrl() + "\n");
for (String chartPackageFile : getChartTgzs(getOutputDirectory())) {
getLog().info("Uploading " + chartPackageFile + "...");
try {
uploadSingle(chartPackageFile);
} catch (BadUploadException | IOException e) {
getLog().error(e.getMessage());
throw new MojoExecutionException("Error uploading " + chartPackageFile + " to " + getHelmUploadUrl(),
e);
}
}
}
@Override
public void execute(ExecutionContext context) throws MojoExecutionException, MojoFailureException {
this.log.info("Preparing project modules for next development cycle.");
this.scmProvider = this.scmProviderRegistry.getProvider();
this.cachedPOMs = Maps.newHashMap();
for (MavenProject project : this.reactorProjects) {
this.log.debug("\tPreparing module '" + ProjectToString.INSTANCE.apply(project) + "'.");
this.cachedPOMs.put(ProjectToCoordinates.EMPTY_VERSION.apply(project), PomUtil.parsePOM(project).get());
try {
Document document = loadAndProcess(project);
PomUtil.writePOM(document, project);
} catch (Throwable t) {
throw new MojoFailureException("Could not update versions for next development cycle.", t);
}
}
this.util.commitChanges(true);
}
@Test
public void testIncludesCustomization() throws MojoExecutionException, IOException {
WebJarPackager packager = new WebJarPackager();
packager.project = mock(MavenProject.class);
packager.projectHelper = mock(MavenProjectHelper.class);
when(packager.project.getArtifactId()).thenReturn("test");
when(packager.project.getVersion()).thenReturn("1.0");
when(packager.project.getBasedir()).thenReturn(fake);
packager.buildDirectory = new File("target/junk");
copy();
packager.webjar = new WebJar();
FileSet set = new FileSet();
set.setDirectory(new File(classes, "assets").getAbsolutePath());
set.setIncludes(ImmutableList.of("**/coffee/*"));
packager.webjar.setFileset(set);
packager.execute();
final File wj = new File(packager.buildDirectory, "test-1.0-webjar.jar");
assertThat(wj).isFile();
JarFile jar = new JarFile(wj);
assertThat(jar.getEntry(WebJarPackager.ROOT + "test/1.0/missing")).isNull();
assertThat(jar.getEntry(WebJarPackager.ROOT + "test/1.0/coffee/script.coffee")).isNotNull();
assertThat(jar.getEntry(WebJarPackager.ROOT + "test/1.0/less/style.less")).isNull();
}
private String[] createForkOnceArgs(List<List<String>> wargs) throws MojoExecutionException {
try {
File f = FileUtils.createTempFile("cxf-w2j", "args");
PrintWriter fw = new PrintWriter(new FileWriter(f));
for (List<String> args : wargs) {
fw.println(Integer.toString(args.size()));
for (String s : args) {
fw.println(s);
}
}
fw.println("-1");
fw.close();
return new String[] {
f.getAbsolutePath()
};
} catch (IOException ex) {
throw new MojoExecutionException("Could not create argument file", ex);
}
}
@Test
public void testStop() throws MojoExecutionException, AppEngineException {
// wire up
stopMojo.host = "host";
stopMojo.port = 124;
// invoke
stopMojo.execute();
// verify
ArgumentCaptor<StopConfiguration> captor = ArgumentCaptor.forClass(StopConfiguration.class);
verify(devServerMock).stop(captor.capture());
Assert.assertEquals("host", captor.getValue().getHost());
Assert.assertEquals(Integer.valueOf(124), captor.getValue().getPort());
}
/**
* Generate the manifest for the über jar.
*/
private void generateManifest(JavaArchive jar, Map<String, String> entries) throws IOException,
MojoExecutionException {
Manifest manifest = new Manifest();
Attributes attributes = manifest.getMainAttributes();
attributes.put(Attributes.Name.MANIFEST_VERSION, "1.0");
if (entries != null) {
for (Map.Entry<String, String> entry : entries.entrySet()) {
attributes.put(new Attributes.Name(entry.getKey()), entry.getValue());
}
}
ByteArrayOutputStream bout = new ByteArrayOutputStream();
manifest.write(bout);
bout.close();
byte[] bytes = bout.toByteArray();
//TODO: merge existing manifest with current one
jar.setManifest(new ByteArrayAsset(bytes));
}
private void assertGeneratedSwaggerSpecYaml(String description) throws MojoExecutionException, MojoFailureException, IOException {
mojo.getApiSources().get(0).setOutputFormats("yaml");
mojo.execute();
DumperOptions options = new DumperOptions();
options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
options.setPrettyFlow(true);
Yaml yaml = new Yaml(options);
String actualYaml = yaml.dump(yaml.load(FileUtils.readFileToString(new File(swaggerOutputDir, "swagger.yaml"))));
String expectYaml = yaml.dump(yaml.load(this.getClass().getResourceAsStream("/expectedOutput/swagger-spring.yaml")));
ObjectMapper mapper = Json.mapper();
JsonNode actualJson = mapper.readTree(YamlToJson(actualYaml));
JsonNode expectJson = mapper.readTree(YamlToJson(expectYaml));
changeDescription(expectJson, description);
assertJsonEquals(expectJson, actualJson, Configuration.empty().when(IGNORING_ARRAY_ORDER));
}
public static void copyDependenciesToBuildDirectory(MavenProject mavenProject,
MavenSession mavenSession,
BuildPluginManager pluginManager) throws MojoExecutionException {
executeMojo(
plugin(
groupId("org.apache.maven.plugins"),
artifactId("maven-dependency-plugin"),
version("2.4")
),
goal("copy-dependencies"),
configuration(
element(name("outputDirectory"), "${project.build.directory}/dependency")
),
executionEnvironment(
mavenProject,
mavenSession,
pluginManager
)
);
}
protected Outline generateCode(final Model model)
throws MojoExecutionException {
if (getVerbose()) {
getLog().info("Compiling input schema(s)...");
}
final Outline outline = model.generateCode(model.options,
new LoggingErrorReceiver("Error while generating code.",
getLog(), getVerbose()));
if (outline == null) {
throw new MojoExecutionException(
"Failed to compile input schema(s)! Error messages should have been provided.");
} else {
return outline;
}
}
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
if (properties == null || properties.isEmpty()) {
throw new MojoExecutionException("Param 'properties' is required");
}
Path propertiesPath = propertiesPath();
try {
getLog().info("Properties to convert: " + propertiesPath);
String content = new String(Files.readAllBytes(propertiesPath));
String yaml = Props2YAML.fromContent(content).convert(useNumericKeysAsArrayIndexes);
Path destinationPath = propertiesPath.getParent().resolve(getFileName());
getLog().info("Write YAML to: " + destinationPath);
try (BufferedWriter writer = Files.newBufferedWriter(destinationPath)) {
writer.write(yaml);
}
} catch (IOException e) {
getLog().error("Failed to convert properties", e);
}
}
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
List<String> debugOptions = computeDebugOptions();
if (jvmArgs == null) {
jvmArgs = new ArrayList<>();
}
jvmArgs.addAll(debugOptions);
if (redeploy) {
getLog().warn("Redeployment and Debug cannot be used together - disabling redeployment");
redeploy = false;
}
getLog().info("The application will wait for a debugger to attach on debugPort " + debugPort);
if (debugSuspend) {
getLog().info("The application will wait for a debugger to attach");
}
super.execute();
}
/** Execute the given mojo.
*
* @param mojo the mojo to execute.
* @throws MojoExecutionException if the mojo cannot be run properly.
* @throws MojoFailureException if the build failed.
*/
public void executeMojo(MojoExecution mojo) throws MojoExecutionException, MojoFailureException {
try {
this.buildPluginManager.executeMojo(this.session, mojo);
} catch (PluginConfigurationException
| PluginManagerException e) {
throw new MojoFailureException(e.getLocalizedMessage(), e);
}
}
protected void setAttributesOnBuilder(AttributesBuilder attributesBuilder) throws MojoExecutionException {
if (embedAssets) {
attributesBuilder.linkCss(false);
attributesBuilder.dataUri(true);
}
AsciidoctorHelper.addAttributes(attributes, attributesBuilder);
if (!attributesChain.isEmpty()) {
getLog().info("Attributes: " + attributesChain);
attributesBuilder.arguments(attributesChain);
}
}
/**
* Creates a native MacOS app bundle
*/
@Override
public File doCreateApp() throws MojoExecutionException {
// sets startup file
this.executable = new File(macOSFolder, "startup");
// copies jarfile to Java folder
FileUtils.copyFileToFolder(jarFile, javaFolder);
// creates startup file to boot java app
VelocityUtils.render("mac/startup.vtl", executable, this);
executable.setExecutable(true, false);
Logger.info("Startup script file created in " + executable.getAbsolutePath());
// copies universalJavaApplicationStub startup file to boot java app
File appStubFile = new File(macOSFolder, "universalJavaApplicationStub");
FileUtils.copyResourceToFile("/mac/universalJavaApplicationStub", appStubFile, true);
appStubFile.setExecutable(true, false);
// creates and write the Info.plist file
File infoPlistFile = new File(contentsFolder, "Info.plist");
VelocityUtils.render("mac/Info.plist.vtl", infoPlistFile, this);
Logger.info("Info.plist file created in " + infoPlistFile.getAbsolutePath());
// codesigns app folder
if (Platform.mac.isCurrentPlatform()) {
CommandUtils.execute("codesign", "--force", "--deep", "--sign", "-", appFile);
} else {
Logger.warn("Generated app could not be signed due to current platform is " + Platform.getCurrentPlatform());
}
return appFile;
}
private void copyGeneratedSources(MojoContext context, Targets.Option parsedTarget) throws MojoExecutionException {
File tmpPath = TempPath.getTempProjectPath(context);
File generatedSources = new File(tmpPath.getAbsolutePath(), parsedTarget.name());
context.show("Copying generated files from " + generatedSources.getAbsolutePath() + " to " + this.generatedSources);
Utils.createDirIfNotExists(this.generatedSources);
Utils.copyFolder(generatedSources, new File(this.generatedSources), context);
}
@Override
protected void doExecute() throws MojoExecutionException, MojoFailureException {
for (ImageTagConfiguration config : images) {
if (!config.getTags().isEmpty()) {
applyTagsToImage(config);
}
}
}
protected void undeployApp(File file) throws MojoExecutionException {
String appName = file.getName().substring(0, file.getName().lastIndexOf('.'));
if (getAppsDirectory().equals("apps")) {
scd = null;
try {
File serverXML = new File(serverDirectory.getCanonicalPath(), "server.xml");
scd = ServerConfigDocument.getInstance(CommonLogger.getInstance(), serverXML, configDirectory,
bootstrapPropertiesFile, bootstrapProperties, serverEnvFile, false);
//appName will be set to a name derived from file if no name can be found.
appName = scd.findNameForLocation(appName);
} catch (Exception e) {
log.warn(e.getLocalizedMessage());
}
}
try {
if (!file.delete()) {
throw new MojoExecutionException(file.toString() + " could not be deleted from the server during undeploy.");
}
} catch (SecurityException se) {
throw new MojoExecutionException(file.toString() + " could not be deleted because access was denied.", se);
}
//check stop message code
String stopMessage = STOP_APP_MESSAGE_CODE_REG + appName;
ServerTask serverTask = initializeJava();
if (serverTask.waitForStringInLog(stopMessage, APP_STOP_TIMEOUT_DEFAULT, new File(serverDirectory, "logs/messages.log")) == null) {
throw new MojoExecutionException("CWWKM2022E: Failed to undeploy application " + file.getPath() + ". The Stop application message cannot be found in console.log.");
}
}