/*
|
* The contents of this file are subject to the terms of the Common Development and
|
* Distribution License (the License). You may not use this file except in compliance with the
|
* License.
|
*
|
* You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
|
* specific language governing permission and limitations under the License.
|
*
|
* When distributing Covered Software, include this CDDL Header Notice in each file and include
|
* the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
|
* Header, with the fields enclosed by brackets [] replaced by your own identifying
|
* information: "Portions Copyright [year] [name of copyright owner]".
|
*
|
* Copyright 2015 ForgeRock AS.
|
*/
|
package org.forgerock.opendj.maven;
|
|
import java.io.BufferedReader;
|
import java.io.BufferedWriter;
|
import java.io.File;
|
import java.io.FileReader;
|
import java.io.FileWriter;
|
import java.io.IOException;
|
import java.util.LinkedList;
|
import java.util.List;
|
import java.util.TreeSet;
|
|
import org.apache.maven.plugin.AbstractMojo;
|
import org.apache.maven.plugin.MojoExecutionException;
|
import org.apache.maven.plugin.MojoFailureException;
|
import org.apache.maven.plugins.annotations.LifecyclePhase;
|
import org.apache.maven.plugins.annotations.Mojo;
|
import org.apache.maven.plugins.annotations.Parameter;
|
import org.apache.maven.project.MavenProject;
|
|
/**
|
* Concatenates the contents of the files in the schema directory to create a
|
* base schema that may be used during the upgrade process. Each element will
|
* also include the X-SCHEMA-FILE extension to indicate the source schema file.
|
* <p>
|
* There is a single goal that generates the base schema.
|
* <p>
|
*/
|
@Mojo(name = "concat", defaultPhase = LifecyclePhase.GENERATE_SOURCES)
|
public final class ConcatSchemaMojo extends AbstractMojo {
|
|
/**
|
* The Maven Project.
|
*/
|
@Parameter(property = "project", required = true, readonly = true)
|
private MavenProject project;
|
|
/**
|
* The path to the directory containing the schema files.
|
*/
|
@Parameter(required = true, defaultValue = "${basedir}/resource/schema")
|
private String schemaDirectory;
|
|
/**
|
* The directory path of the concatenated schema file to create. Must be in ${project.build.directory}
|
*/
|
@Parameter(required = true)
|
private String outputDirectory;
|
|
/**
|
* The file name of the concatenated schema file to create.
|
*/
|
@Parameter(required = true)
|
private String outputFile;
|
|
/** {@inheritDoc} */
|
@Override
|
public void execute() throws MojoExecutionException, MojoFailureException {
|
String projectBuildDir = project.getBuild().getDirectory();
|
String outputFilePath = outputDirectory + System.getProperty("file.separator") + outputFile;
|
|
if (!outputDirectory.contains(projectBuildDir)) {
|
String errorMsg = String.format("outputDirectory parameter (%s) must be included "
|
+ "in ${project.build.directory} (%s)", outputDirectory, projectBuildDir);
|
getLog().error(errorMsg);
|
throw new MojoExecutionException(errorMsg);
|
}
|
getLog().info(String.format("Concatenating all ldif files from directory: %s", schemaDirectory));
|
getLog().info(String.format("Concatenated file: %s", outputFilePath));
|
|
new File(outputFilePath).getParentFile().mkdirs();
|
|
// Get a sorted list of the files in the schema directory.
|
TreeSet<String> schemaFileNames = new TreeSet<>();
|
for (File f : new File(schemaDirectory).listFiles()) {
|
if (f.isFile()) {
|
schemaFileNames.add(f.getName());
|
}
|
}
|
|
// Create a set of lists that will hold the schema elements read from the files.
|
LinkedList<String> attributeTypes = new LinkedList<>();
|
LinkedList<String> objectClasses = new LinkedList<>();
|
LinkedList<String> nameForms = new LinkedList<>();
|
LinkedList<String> ditContentRules = new LinkedList<>();
|
LinkedList<String> ditStructureRules = new LinkedList<>();
|
LinkedList<String> matchingRuleUses = new LinkedList<>();
|
LinkedList<String> ldapSyntaxes = new LinkedList<>();
|
int curLineNumber = 0;
|
|
// Open each of the files in order and read the elements that they contain,
|
// appending them to the appropriate lists.
|
for (String name : schemaFileNames) {
|
// Read the contents of the file into a list with one schema element per
|
// list element.
|
LinkedList<StringBuilder> lines = new LinkedList<>();
|
try {
|
BufferedReader reader = new BufferedReader(new FileReader(new File(schemaDirectory, name)));
|
String line = reader.readLine();
|
while (line != null) {
|
curLineNumber++;
|
if (line.length() > 0 && !line.startsWith("#")) {
|
if (line.startsWith(" ")) {
|
lines.getLast().append(line.substring(1));
|
} else {
|
lines.add(new StringBuilder(line));
|
}
|
}
|
line = reader.readLine();
|
}
|
reader.close();
|
} catch (Exception e) {
|
getLog().error(String.format(
|
"Error while reading schema file %s at line %d: %s", name, curLineNumber, e.getMessage()));
|
throw new MojoExecutionException(e.getMessage(), e);
|
}
|
|
// Iterate through each line in the list. Find the colon and get the
|
// attribute name at the beginning. If it's someting that we don't
|
// recognize, then skip it. Otherwise, add the X-SCHEMA-FILE extension
|
// and add it to the appropriate schema element list.
|
for (StringBuilder buffer : lines) {
|
// Get the line and add the X-SCHEMA-FILE extension to the end of it.
|
// All of them should end with " )" but some might have the parenthesis
|
// crammed up against the last character so deal with that as well.
|
String line = buffer.toString().trim();
|
if (line.endsWith(" )")) {
|
line = line.substring(0, line.length() - 1) + "X-SCHEMA-FILE '" + name + "' )";
|
} else if (line.endsWith(")")) {
|
line = line.substring(0, line.length() - 1) + " X-SCHEMA-FILE '" + name + "' )";
|
} else {
|
continue;
|
}
|
|
String lowerLine = line.toLowerCase();
|
if (lowerLine.startsWith("attributetypes:")) {
|
attributeTypes.add(line);
|
} else if (lowerLine.startsWith("objectclasses:")) {
|
objectClasses.add(line);
|
} else if (lowerLine.startsWith("nameforms:")) {
|
nameForms.add(line);
|
} else if (lowerLine.startsWith("ditcontentrules:")) {
|
ditContentRules.add(line);
|
} else if (lowerLine.startsWith("ditstructurerules:")) {
|
ditStructureRules.add(line);
|
} else if (lowerLine.startsWith("matchingruleuse:")) {
|
matchingRuleUses.add(line);
|
} else if (lowerLine.startsWith("ldapsyntaxes:")) {
|
ldapSyntaxes.add(line);
|
}
|
}
|
}
|
|
// Write the resulting output to the merged schema file.
|
try {
|
BufferedWriter writer = new BufferedWriter(new FileWriter(outputFilePath));
|
writer.write("dn: cn=schema");
|
writer.newLine();
|
writer.write("objectClass: top");
|
writer.newLine();
|
writer.write("objectClass: ldapSubentry");
|
writer.newLine();
|
writer.write("objectClass: subschema");
|
writer.newLine();
|
|
writeSchemaElements(ldapSyntaxes, writer);
|
writeSchemaElements(attributeTypes, writer);
|
writeSchemaElements(objectClasses, writer);
|
writeSchemaElements(nameForms, writer);
|
writeSchemaElements(ditContentRules, writer);
|
writeSchemaElements(ditStructureRules, writer);
|
writeSchemaElements(matchingRuleUses, writer);
|
|
writer.close();
|
} catch (Exception e) {
|
getLog().error(
|
String.format("Error while writing concatenated schema file %s: %s", outputFile, e.getMessage()));
|
throw new MojoExecutionException(e.getMessage(), e);
|
}
|
}
|
|
private void writeSchemaElements(List<String> schemaElements, BufferedWriter writer) throws IOException {
|
for (String line : schemaElements) {
|
writer.write(line);
|
writer.newLine();
|
}
|
}
|
|
}
|
