/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
|
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
|
* add the following below this CDDL HEADER, with the fields enclosed
|
* by brackets "[]" replaced with your own identifying information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
*
|
* Copyright 2008-2010 Sun Microsystems, Inc.
|
* Portions Copyright 2011-2012 ForgeRock AS
|
*/
|
package org.opends.build.tools;
|
|
import org.apache.tools.ant.Task;
|
import org.apache.tools.ant.BuildException;
|
import org.apache.tools.ant.Project;
|
import static org.opends.build.tools.Utilities.*;
|
import org.opends.messages.Category;
|
import org.opends.messages.Severity;
|
import org.opends.messages.MessageDescriptor;
|
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.FileReader;
|
import java.io.BufferedReader;
|
import java.io.FileNotFoundException;
|
import java.io.FileOutputStream;
|
import java.io.InputStream;
|
import java.io.InputStreamReader;
|
import java.io.PrintWriter;
|
import java.io.DataOutputStream;
|
import java.io.IOException;
|
import java.text.DateFormat;
|
import java.text.SimpleDateFormat;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.Properties;
|
import java.util.List;
|
import java.util.ArrayList;
|
import java.util.TreeSet;
|
import java.util.UnknownFormatConversionException;
|
import java.util.Calendar;
|
import java.util.Arrays;
|
import java.util.Locale;
|
import java.util.Map;
|
import java.util.TreeMap;
|
import java.util.HashSet;
|
import java.util.Set;
|
import java.util.EnumSet;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
/**
|
* Generates a Java class containing representations of messages
|
* found in a properties file.
|
*/
|
public class GenerateMessageFile extends Task {
|
|
private File source;
|
private File dest;
|
private boolean overwrite;
|
private boolean writeLogRef;
|
|
static private final String MESSAGES_FILE_STUB =
|
"resource/Messages.java.stub";
|
|
/*
|
* The registry filename is the result of the concatenation of the
|
* location of where the source are generated, the package name and the
|
* DESCRIPTORS_REG value.
|
*/
|
static private String REGISTRY_FILE_NAME;
|
|
static private final String DESCRIPTORS_REG = "descriptors.reg";
|
|
/**
|
* Used to set a category for all messages in the property file.
|
* If set, the category for each message need not be encoded in
|
* the message's property file key.
|
*/
|
static private final String GLOBAL_CATEGORY = "global.category";
|
|
/**
|
* Used to set a severity for all messages in the property file.
|
* If set, the severity for each message need not be encoded in
|
* the message's property file key.
|
*/
|
static private final String GLOBAL_SEVERITY = "global.severity";
|
|
/**
|
* Used to set a category mask for all messages in the property
|
* file. If set, the category will automatically be assigned
|
* USER_DEFINED and the value of <code>GLOBAL_CATEGORY</code>
|
* will be ignored.
|
*/
|
static private final String GLOBAL_CATEGORY_MASK = "global.mask";
|
|
/**
|
* When true generates messages that have no ordinals.
|
*/
|
static private final String GLOBAL_ORDINAL = "global.ordinal";
|
|
/**
|
* When true and if the Java Web Start property is set use the class loader of
|
* the jar where the MessageDescriptor is contained to retrieve the
|
* ResourceBundle.
|
*/
|
static private final String GLOBAL_USE_MESSAGE_JAR_IF_WEBSTART =
|
"global.use.message.jar.if.webstart";
|
|
static private final Set<String> DIRECTIVE_PROPERTIES = new HashSet<String>();
|
static {
|
DIRECTIVE_PROPERTIES.add(GLOBAL_CATEGORY);
|
DIRECTIVE_PROPERTIES.add(GLOBAL_CATEGORY_MASK);
|
DIRECTIVE_PROPERTIES.add(GLOBAL_SEVERITY);
|
DIRECTIVE_PROPERTIES.add(GLOBAL_ORDINAL);
|
DIRECTIVE_PROPERTIES.add(GLOBAL_USE_MESSAGE_JAR_IF_WEBSTART);
|
}
|
|
static private final String SPECIFIER_REGEX =
|
"%(\\d+\\$)?([-#+ 0,(\\<]*)?(\\d+)?(\\.\\d+)?([tT])?([a-zA-Z%])";
|
|
private final Pattern SPECIFIER_PATTERN = Pattern.compile(SPECIFIER_REGEX);
|
|
/**
|
* Message giving formatting rules for string keys.
|
*/
|
static public String KEY_FORM_MSG;
|
|
static {
|
KEY_FORM_MSG = new StringBuilder()
|
.append(".\n\nOpenDJ message property keys must be of the form\n\n")
|
.append("\t\'[CATEGORY]_[SEVERITY]_[DESCRIPTION]_[ORDINAL]\'\n\n")
|
.append("where\n\n")
|
.append("CATEGORY is one of ")
|
.append(EnumSet.allOf(Category.class))
|
.append("\n\nSEVERITY is one of ")
|
.append(Severity.getPropertyKeyFormSet().toString())
|
.append("\n\nDESCRIPTION is a descriptive string composed ")
|
.append("of uppercase character, digits and underscores ")
|
.append("describing the purpose of the message ")
|
.append("\n\nORDINAL is an integer between 0 and 65535 that is ")
|
.append("unique to other messages defined in this file.\n\n")
|
.append("You can relax the mandate for including the CATEGORY, ")
|
.append("SEVERITY, and/or ORDINAL by including one or more ")
|
.append("of the following respective property directives in your ")
|
.append("properties file: ")
|
.append(GLOBAL_CATEGORY)
|
.append(", ")
|
.append(GLOBAL_SEVERITY)
|
.append(", ")
|
.append(GLOBAL_ORDINAL)
|
.append("and setting their value appropriately.")
|
.toString();
|
}
|
|
/*
|
* ISO_LANGUAGES contains all official supported languages for i18n
|
*/
|
private static final List<String> ISO_LANGUAGES =
|
Arrays.asList(Locale.getISOLanguages());
|
/*
|
* ISO_COUNTRIES contains all official supported countries for i18n
|
*/
|
private static final List<String> ISO_COUNTRIES =
|
Arrays.asList(Locale.getISOCountries());
|
|
/*
|
* A Pattern instance that matches "<label>_<language>_<country>.properties"
|
* where <label> can be anything including '_'
|
* <language> a two characters code contained in the ISO_LANGUAGES list
|
* <country> a two characters code contained in the ISO_COUNTRIES list
|
*/
|
private static final Pattern LANGUAGE_COUNTRY_MATCHER =
|
Pattern.compile("(.*)_([a-z]{2})_([A-Z]{2}).properties");
|
/*
|
* A Pattern instance that matches "<label>_<language>.properties"
|
* where <label> and <language> have same definition as above.
|
*/
|
private static final Pattern LANGUAGE_MATCHER =
|
Pattern.compile("(.*)_([a-z]{2}).properties");
|
|
/**
|
* Representation of a format specifier (for example %s).
|
*/
|
private class FormatSpecifier {
|
|
private String[] sa;
|
|
/**
|
* Creates a new specifier.
|
* @param sa specifier components
|
*/
|
FormatSpecifier(String[] sa) {
|
this.sa = sa;
|
}
|
|
/**
|
* Indicates whether or not the specifier uses argument
|
* indexes (for example 2$).
|
* @return boolean true if this specifier uses indexing
|
*/
|
public boolean specifiesArgumentIndex() {
|
return this.sa[0] != null;
|
}
|
|
/**
|
* Returns a java class associated with a particular formatter
|
* based on the conversion type of the specifier.
|
* @return Class for representing the type of argument used
|
* as a replacement for this specifier.
|
*/
|
public Class<?> getSimpleConversionClass() {
|
Class<?> c = null;
|
String sa4 = sa[4] != null ? sa[4].toLowerCase() : null;
|
String sa5 = sa[5] != null ? sa[5].toLowerCase() : null;
|
if ("t".equals(sa4)) {
|
c = Calendar.class;
|
} else if (
|
"b".equals(sa5)) {
|
c = Boolean.class;
|
} else if (
|
"h".equals(sa5)) {
|
c = Integer.class;
|
} else if (
|
"s".equals(sa5)) {
|
c = CharSequence.class;
|
} else if (
|
"c".equals(sa5)) {
|
c = Character.class;
|
} else if (
|
"d".equals(sa5) ||
|
"o".equals(sa5) ||
|
"x".equals(sa5) ||
|
"e".equals(sa5) ||
|
"f".equals(sa5) ||
|
"g".equals(sa5) ||
|
"a".equals(sa5)) {
|
c = Number.class;
|
} else if (
|
"n".equals(sa5) ||
|
"%".equals(sa5)) {
|
// ignore literals
|
}
|
return c;
|
}
|
|
}
|
|
/**
|
* Represents a message to be written into the messages files.
|
*/
|
private class MessageDescriptorDeclaration {
|
|
private MessagePropertyKey key;
|
private String formatString;
|
private List<FormatSpecifier> specifiers;
|
private List<Class<?>> classTypes;
|
private String[] constructorArgs;
|
|
/**
|
* Creates a parameterized instance.
|
* @param key of the message
|
* @param formatString of the message
|
*/
|
public MessageDescriptorDeclaration(MessagePropertyKey key,
|
String formatString) {
|
this.key = key;
|
this.formatString = formatString;
|
this.specifiers = parse(formatString);
|
this.classTypes = new ArrayList<Class<?>>();
|
for (FormatSpecifier f : specifiers) {
|
Class<?> c = f.getSimpleConversionClass();
|
if (c != null) {
|
classTypes.add(c);
|
}
|
}
|
}
|
|
/**
|
* Gets the name of the Java class that will be used to represent
|
* this message's type.
|
* @return String representing the Java class name
|
*/
|
public String getDescriptorClassDeclaration() {
|
StringBuilder sb = new StringBuilder();
|
if (useGenericMessageTypeClass()) {
|
sb.append(getShortClassName(MessageDescriptor.class));
|
sb.append(".");
|
sb.append(MessageDescriptor.DESCRIPTOR_CLASS_BASE_NAME);
|
sb.append("N");
|
} else {
|
sb.append(getShortClassName(MessageDescriptor.class));
|
sb.append(".");
|
sb.append(MessageDescriptor.DESCRIPTOR_CLASS_BASE_NAME);
|
sb.append(classTypes.size());
|
sb.append(getClassTypeVariables());
|
}
|
return sb.toString();
|
}
|
|
/**
|
* Gets a string representing the message type class' variable
|
* information (for example '<String,Integer>') that is based on
|
* the type of arguments specified by the specifiers in this message.
|
* @return String representing the message type class parameters
|
*/
|
public String getClassTypeVariables() {
|
StringBuilder sb = new StringBuilder();
|
if (classTypes.size() > 0) {
|
sb.append("<");
|
for (int i = 0; i < classTypes.size(); i++) {
|
Class<?> c = classTypes.get(i);
|
if (c != null) {
|
sb.append(getShortClassName(c));
|
if (i < classTypes.size() - 1) {
|
sb.append(",");
|
}
|
}
|
}
|
sb.append(">");
|
}
|
return sb.toString();
|
}
|
|
/**
|
* Gets the javadoc comments that will appear above the messages declaration
|
* in the messages file.
|
* @return String comment
|
*/
|
public String getComment() {
|
StringBuilder sb = new StringBuilder();
|
sb.append(indent(1)).append("/**").append(EOL);
|
|
// Unwrapped so that you can search through the descriptor
|
// file for a message and not have to worry about line breaks
|
String ws = formatString; // wrapText(formatString, 70);
|
|
String[] sa = ws.split(EOL);
|
for (String s : sa) {
|
sb.append(indent(1)).append(" * ").append(s).append(EOL);
|
}
|
sb.append(indent(1)).append(" */").append(EOL);
|
return sb.toString();
|
}
|
|
/**
|
* Sets the arguments that will be supplied in the declaration
|
* of the message.
|
* @param s array of string arguments that will be passed
|
* in the constructor
|
*/
|
public void setConstructorArguments(String... s) {
|
this.constructorArgs = s;
|
}
|
|
/**
|
* {@inheritDoc}
|
*/
|
public String toString() {
|
StringBuilder sb = new StringBuilder();
|
sb.append(getComment());
|
sb.append(indent(1));
|
sb.append("public static final ");
|
sb.append(getDescriptorClassDeclaration());
|
sb.append(" ");
|
sb.append(key.getMessageDescriptorName());
|
sb.append(" =");
|
sb.append(EOL);
|
sb.append(indent(5));
|
sb.append("new ");
|
sb.append(getDescriptorClassDeclaration());
|
sb.append("(");
|
if (constructorArgs != null) {
|
for (int i = 0; i < constructorArgs.length; i++) {
|
sb.append(constructorArgs[i]);
|
if (i < constructorArgs.length - 1) {
|
sb.append(",");
|
}
|
}
|
sb.append(", ");
|
}
|
sb.append("getClassLoader()");
|
sb.append(");");
|
return sb.toString();
|
}
|
|
/**
|
* Indicates whether the generic message type class should
|
* be used. In general this is when a format specifier is
|
* more complicated than we support or when the number of
|
* arguments exceeeds the number of specific message type
|
* classes (MessageType0, MessageType1 ...) that are defined.
|
* @return boolean indicating
|
*/
|
private boolean useGenericMessageTypeClass() {
|
if (specifiers.size() > MessageDescriptor.DESCRIPTOR_MAX_ARG_HANDLER) {
|
return true;
|
} else if (specifiers != null) {
|
for (FormatSpecifier s : specifiers) {
|
if (s.specifiesArgumentIndex()) {
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
/**
|
* Look for format specifiers in the format string.
|
* @param s format string
|
* @return list of format specifiers
|
*/
|
private List<FormatSpecifier> parse(String s) {
|
List<FormatSpecifier> sl = new ArrayList<FormatSpecifier>();
|
Matcher m = SPECIFIER_PATTERN.matcher(s);
|
int i = 0;
|
while (i < s.length()) {
|
if (m.find(i)) {
|
// Anything between the start of the string and the beginning
|
// of the format specifier is either fixed text or contains
|
// an invalid format string.
|
if (m.start() != i) {
|
// Make sure we didn't miss any invalid format specifiers
|
checkText(s.substring(i, m.start()));
|
// Assume previous characters were fixed text
|
//al.add(new FixedString(s.substring(i, m.start())));
|
}
|
|
// Expect 6 groups in regular expression
|
String[] sa = new String[6];
|
for (int j = 0; j < m.groupCount(); j++) {
|
sa[j] = m.group(j + 1);
|
}
|
sl.add(new FormatSpecifier(sa));
|
i = m.end();
|
} else {
|
// No more valid format specifiers. Check for possible invalid
|
// format specifiers.
|
checkText(s.substring(i));
|
// The rest of the string is fixed text
|
//al.add(new FixedString(s.substring(i)));
|
break;
|
}
|
}
|
return sl;
|
}
|
|
private void checkText(String s) {
|
int idx;
|
// If there are any '%' in the given string, we got a bad format
|
// specifier.
|
if ((idx = s.indexOf('%')) != -1) {
|
char c = (idx > s.length() - 2 ? '%' : s.charAt(idx + 1));
|
throw new UnknownFormatConversionException(String.valueOf(c));
|
}
|
}
|
|
}
|
|
/**
|
* Sets the source of the messages.
|
* @param source File representing the properties
|
* file containing messages
|
*/
|
public void setSourceProps(File source) {
|
this.source = source;
|
}
|
|
/**
|
* Sets the file that will be generated containing
|
* declarations of messages from <code>source</code>.
|
* @param dest File destination
|
*/
|
public void setDestJava(File dest) {
|
this.dest = dest;
|
|
try {
|
File descriptorsRegFile =
|
new File(dest.getParentFile(), DESCRIPTORS_REG);
|
|
if (REGISTRY_FILE_NAME != null) {
|
// if REGISTRY_FILE_NAME is already set, ensure that we computed the
|
// same one
|
File prevDescriptorsRegFile = new File(REGISTRY_FILE_NAME);
|
if (!prevDescriptorsRegFile.equals(descriptorsRegFile)) {
|
throw new BuildException("Error processing " + dest
|
+ ": all messages must be located in the same package thus "
|
+ "name of the source file should be "
|
+ new File(prevDescriptorsRegFile.getParent(), dest.getName()));
|
}
|
} else {
|
REGISTRY_FILE_NAME = descriptorsRegFile.getCanonicalPath();
|
}
|
} catch (Exception e) {
|
throw (new BuildException(e));
|
}
|
}
|
|
/**
|
* Indicates when true that an existing destination
|
* file will be overwritten.
|
* @param o boolean where true means overwrite
|
*/
|
public void setOverwrite(boolean o) {
|
this.overwrite = o;
|
}
|
|
/**
|
* Indicates when true that an XML log message reference should be generated
|
* instead of a Java messages file.
|
*
|
* @param xml
|
* true means write an XML log message reference
|
*/
|
public void setWriteLogRef(boolean xml) {
|
this.writeLogRef = xml;
|
}
|
|
/**
|
* Represents a log reference entry for an individual message.
|
*/
|
private class MessageRefEntry implements Comparable<MessageRefEntry>
|
{
|
|
private Severity severity;
|
private Integer id;
|
private String formatString;
|
|
/**
|
* Build log reference entry for an log message.
|
*
|
* @param category
|
* @param severity
|
* @param ordinal
|
* @param formatString
|
*/
|
public MessageRefEntry(final Category category, final Severity severity,
|
final Integer ordinal, final String formatString)
|
{
|
this.severity = severity;
|
this.formatString = formatString;
|
id = calculateId(category, severity, ordinal);
|
}
|
|
private Integer calculateId(final Category category,
|
final Severity severity, final Integer ordinal)
|
{
|
return new Integer(ordinal | category.getMask() | severity.getMask());
|
}
|
|
/**
|
* Return a DocBook XML <varlistentry> of this log reference entry.
|
* This implementation copies the message string verbatim, and does not
|
* interpret format specifiers.
|
*
|
* @return DocBook XML <varlistentry>.
|
*/
|
public String toString()
|
{
|
return
|
" <varlistentry xml:id=\"log-ref-" + id.intValue() + "\">" + EOL
|
+ " <term>ID: " + id.intValue() + "</term>" + EOL
|
+ " <listitem>" + EOL
|
+ " <para>Severity: " + severity.name() + "</para>" + EOL
|
+ " <para>Message: " + formatString + "</para>" + EOL
|
+ " </listitem>" + EOL + " </varlistentry>" + EOL;
|
}
|
|
/**
|
* Calls {@link #toString()}.
|
*/
|
public String toXML()
|
{
|
return toString();
|
}
|
|
/**
|
* The unique message identifier is calculated using the category, severity,
|
* and message ordinal.
|
*
|
* @return unique message identifier
|
*/
|
public Integer getId()
|
{
|
return this.id;
|
}
|
|
/**
|
* Compare message entries by unique identifier.
|
*
|
* @return See {@link java.lang.Comparable#compareTo(Object)}.
|
*/
|
public int compareTo(MessageRefEntry mre)
|
{
|
return this.id.compareTo(mre.getId());
|
}
|
}
|
|
/**
|
* One-line descriptions for log reference categories
|
*/
|
static private HashMap<String,String> CATEGORY_DESCRIPTIONS;
|
static {
|
CATEGORY_DESCRIPTIONS = new HashMap<String,String>();
|
CATEGORY_DESCRIPTIONS.put("ACCESS_CONTROL", "Access Control.");
|
CATEGORY_DESCRIPTIONS.put("ADMIN", "the administration framework.");
|
CATEGORY_DESCRIPTIONS.put("ADMIN_TOOL", "the tool like the offline"
|
+ " installer and uninstaller.");
|
CATEGORY_DESCRIPTIONS.put("BACKEND", "generic backends.");
|
CATEGORY_DESCRIPTIONS.put("CONFIG", "configuration handling.");
|
CATEGORY_DESCRIPTIONS.put("CORE", "the core server.");
|
CATEGORY_DESCRIPTIONS.put("DSCONFIG", "the dsconfig administration tool.");
|
CATEGORY_DESCRIPTIONS.put("EXTENSIONS", "server extensions for example,"
|
+ " extended operations, SASL mechanisms, password storage"
|
+ " schemes, password validators, and so on).");
|
CATEGORY_DESCRIPTIONS.put("JEB", "the JE backend.");
|
CATEGORY_DESCRIPTIONS.put("LOG", "the server loggers.");
|
CATEGORY_DESCRIPTIONS.put("PLUGIN", "plugin processing.");
|
CATEGORY_DESCRIPTIONS.put("PROTOCOL", "connection and protocol handling"
|
+ " (for example, ASN.1 and LDAP).");
|
CATEGORY_DESCRIPTIONS.put("QUICKSETUP", "quicksetup tools.");
|
CATEGORY_DESCRIPTIONS.put("RUNTIME_INFORMATION", "the runtime"
|
+ " information.");
|
CATEGORY_DESCRIPTIONS.put("SCHEMA", "the server schema elements.");
|
CATEGORY_DESCRIPTIONS.put("SYNC", "the Synchronization.");
|
CATEGORY_DESCRIPTIONS.put("TASK", "tasks.");
|
CATEGORY_DESCRIPTIONS.put("THIRD_PARTY", "third-party (including"
|
+ " user-defined) modules.");
|
CATEGORY_DESCRIPTIONS.put("TOOLS", "tools.");
|
CATEGORY_DESCRIPTIONS.put("USER_DEFINED", "user-defined modules.");
|
CATEGORY_DESCRIPTIONS.put("UTIL", "the general server utilities.");
|
CATEGORY_DESCRIPTIONS.put("VERSION", "version information.");
|
}
|
|
/**
|
* Represents a log reference list of messages for a category.
|
*/
|
private class MessageRefCategory
|
{
|
private Category category;
|
private TreeSet<MessageRefEntry> messages;
|
private String description;
|
|
MessageRefCategory(final Category category,
|
final TreeSet<MessageRefEntry> messages)
|
{
|
this.category = category;
|
this.messages = messages;
|
this.description = getDescription(category);
|
}
|
|
private String getDescription(final Category category)
|
{
|
return "<para>This category concerns messages associated with "
|
+ CATEGORY_DESCRIPTIONS.get(category.name()) + "</para>" + EOL;
|
}
|
|
/**
|
* Return a DocBook XML <variablelist> of this log reference category.
|
*
|
* @return DocBook XML <variablelist>
|
*/
|
public String toString()
|
{
|
StringBuilder entries = new StringBuilder();
|
for (MessageRefEntry entry : messages)
|
{
|
entries.append(entry.toXML());
|
}
|
|
return getVariablelistHead() + entries.toString() + getVariablelistTail();
|
}
|
|
/**
|
* Calls {@link #toString()}.
|
*/
|
public String toXML()
|
{
|
return toString();
|
}
|
|
private String getXMLPreamble()
|
{
|
DateFormat df = new SimpleDateFormat("yyyy");
|
Date now = new Date();
|
String year = df.format(now);
|
|
return new StringBuilder()
|
.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>").append(EOL)
|
.append("<!--").append(EOL)
|
.append(" ! CCPL HEADER START").append(EOL)
|
.append(" !").append(EOL)
|
.append(" ! This work is licensed under the Creative Commons").append(EOL)
|
.append(" ! Attribution-NonCommercial-NoDerivs 3.0 Unported License.").append(EOL)
|
.append(" ! To view a copy of this license, visit").append(EOL)
|
.append(" ! http://creativecommons.org/licenses/by-nc-nd/3.0/").append(EOL)
|
.append(" ! or send a letter to Creative Commons, 444 Castro Street,").append(EOL)
|
.append(" ! Suite 900, Mountain View, California, 94041, USA.").append(EOL)
|
.append(" !").append(EOL)
|
.append(" ! See the License for the specific language governing permissions").append(EOL)
|
.append(" ! and limitations under the License.").append(EOL)
|
.append(" !").append(EOL)
|
.append(" ! If applicable, add the following below this CCPL HEADER, with the fields").append(EOL)
|
.append(" ! enclosed by brackets \"[]\" replaced with your own identifying information:").append(EOL)
|
.append(" ! Portions Copyright [yyyy] [name of copyright owner]").append(EOL)
|
.append(" !").append(EOL)
|
.append(" ! CCPL HEADER END").append(EOL)
|
.append(" !").append(EOL)
|
.append(" ! Copyright " + year + " ForgeRock AS").append(EOL)
|
.append(" !").append(EOL)
|
.append("-->").append(EOL)
|
.toString();
|
}
|
|
private String getBaseElementAttrs()
|
{
|
return "xmlns='http://docbook.org/ns/docbook'"
|
+ " version='5.0' xml:lang='en'"
|
+ " xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'"
|
+ " xsi:schemaLocation='http://docbook.org/ns/docbook"
|
+ " http://docbook.org/xml/5.0/xsd/docbook.xsd'"
|
+ " xmlns:xlink='http://www.w3.org/1999/xlink'"
|
+ " xmlns:xinclude='http://www.w3.org/2001/XInclude'";
|
}
|
|
private String getVariablelistHead()
|
{
|
return getXMLPreamble() + " <variablelist xml:id=\"log-ref-"
|
+ this.category.name() + "\" " + getBaseElementAttrs() + ">" + EOL
|
+ " <title>Log Message Category: " + category.name() + "</title>"
|
+ EOL + " " + this.description;
|
}
|
|
private String getVariablelistTail()
|
{
|
return " </variablelist>" + EOL;
|
}
|
|
}
|
|
/**
|
* {@inheritDoc}
|
*/
|
@Override
|
public void execute() throws BuildException {
|
|
if ( this.dest == null ) {
|
// this is an example-plugin call:
|
// - check the source file is not a localization
|
// - guess the destination filename from source filename
|
String sourcefilename = source.getAbsolutePath();
|
int filenameIndex = sourcefilename.lastIndexOf(File.separator)+1;
|
String pathname = sourcefilename.substring(0, filenameIndex);
|
String filename = sourcefilename.substring(filenameIndex);
|
|
/*
|
* Make sure only <label>.properties are generated thus avoiding to
|
* generate messages for localized properties files.
|
*/
|
Matcher matcher = LANGUAGE_COUNTRY_MATCHER.matcher(filename);
|
if ( matcher.find() ) {
|
if ( ISO_LANGUAGES.contains(matcher.group(2))
|
&& ISO_COUNTRIES.contains(matcher.group(3)) ) {
|
// do not generate message for <label>_<language>_<country>.properties
|
return;
|
}
|
}
|
|
matcher = LANGUAGE_MATCHER.matcher(filename);
|
if ( matcher.find() ) {
|
if ( ISO_LANGUAGES.contains(matcher.group(2)) ) {
|
// do not generate message for <label>_<language>.properties
|
return;
|
}
|
}
|
|
// filename without ".properties"
|
filename = filename.substring(0, filename.length()-11);
|
// change to src-generated directory keeping package name
|
if (writeLogRef) {
|
pathname = pathname.replace(getProject().getProperty("msg.dir"),
|
getProject().getProperty("msg.logref.dir"));
|
} else {
|
pathname = pathname.replace(getProject().getProperty("msg.dir"),
|
getProject().getProperty("msg.javagen.dir"));
|
}
|
|
|
// append characters from filename to pathname starting with an uppercase
|
// letter, ignoring '_' and uppering all characters prefixed with "_"
|
StringBuilder sb = new StringBuilder(pathname);
|
boolean upperCaseNextChar = true;
|
for(char c : filename.toCharArray()) {
|
if ( c == '_' || c == '-' ) {
|
upperCaseNextChar = true;
|
continue;
|
}
|
if ( upperCaseNextChar ) {
|
sb.append(Character.toUpperCase(c));
|
upperCaseNextChar = false;
|
} else {
|
sb.append(c);
|
}
|
}
|
if (writeLogRef) {
|
sb.append("Messages.xml");
|
} else {
|
sb.append("Messages.java");
|
}
|
|
setDestJava(new File(sb.toString()));
|
}
|
|
BufferedReader stubReader = null;
|
PrintWriter destWriter = null;
|
try {
|
|
// Decide whether to generate messages based on modification
|
// times and print status messages.
|
if (!source.exists()) {
|
throw new BuildException("file " + source.getName() +
|
" does not exist");
|
}
|
if (dest.exists()) {
|
if (this.overwrite || source.lastModified() > dest.lastModified()) {
|
dest.delete();
|
log("Regenerating " + dest.getName() + " from " + source.getName());
|
} else {
|
log(dest.getName() + " is up to date");
|
return;
|
}
|
} else {
|
File javaGenDir = dest.getParentFile();
|
if (!javaGenDir.exists()) {
|
javaGenDir.mkdirs();
|
}
|
log("Generating " + dest.getName() + " from " + source.getName());
|
}
|
|
stubReader = new BufferedReader(new InputStreamReader(getStubFile(),
|
"UTF-8"));
|
destWriter = new PrintWriter(dest, "UTF-8");
|
String stubLine;
|
Properties properties = new Properties();
|
properties.load(new FileInputStream(source));
|
TreeSet<MessageRefEntry> messageRefEntries =
|
new TreeSet<MessageRefEntry>();
|
while (null != (stubLine = stubReader.readLine())) {
|
if (stubLine.contains("${MESSAGES}")) {
|
Integer globalOrdinal = null;
|
String go = properties.getProperty(GLOBAL_ORDINAL);
|
if (go != null) {
|
globalOrdinal = new Integer(go);
|
}
|
|
// Determine the value of the global category/mask if set
|
Integer globalMask = null;
|
Category globalCategory = null;
|
String gms = properties.getProperty(GLOBAL_CATEGORY_MASK);
|
if (gms != null) {
|
globalMask = Integer.parseInt(gms);
|
globalCategory = Category.USER_DEFINED;
|
} else {
|
String gcs = properties.getProperty(GLOBAL_CATEGORY);
|
if (gcs != null) {
|
globalCategory = Category.valueOf(gcs);
|
}
|
}
|
|
// Determine the value of the global severity
|
Severity globalSeverity = null;
|
String gss = properties.getProperty(GLOBAL_SEVERITY);
|
if (gss != null) {
|
globalSeverity = Severity.parseString(gss);
|
}
|
|
Map<MessagePropertyKey,String> keyMap =
|
new TreeMap<MessagePropertyKey,String>();
|
|
for (Object propO : properties.keySet()) {
|
String propKey = propO.toString();
|
try {
|
if (!DIRECTIVE_PROPERTIES.contains(propKey)) {
|
MessagePropertyKey key =
|
MessagePropertyKey.parseString(
|
propKey,
|
globalCategory == null,
|
globalSeverity == null,
|
globalOrdinal == null);
|
String formatString = properties.getProperty(propKey);
|
keyMap.put(key, formatString);
|
}
|
} catch (IllegalArgumentException iae) {
|
throw new BuildException(
|
"ERROR: invalid property key " + propKey +
|
": " + iae.getMessage() +
|
KEY_FORM_MSG);
|
}
|
}
|
|
int usesOfGenericDescriptor = 0;
|
|
Category firstCategory = null;
|
Set<Integer> usedOrdinals = new HashSet<Integer>();
|
for (MessagePropertyKey key : keyMap.keySet()) {
|
String formatString = keyMap.get(key);
|
MessageDescriptorDeclaration message =
|
new MessageDescriptorDeclaration(key, formatString);
|
|
Category c = (globalCategory != null ?
|
globalCategory : key.getCategory());
|
|
// Check that this category is the same as all the
|
// others in this file. Maybe this should be an error?
|
if (firstCategory != null) {
|
if (!firstCategory.equals(c)) {
|
log("WARNING: multiple categories defined in " + source);
|
}
|
} else {
|
firstCategory = c;
|
}
|
|
Severity s = (globalSeverity != null ?
|
globalSeverity : key.getSeverity());
|
|
if (c == null) {
|
throw new BuildException(
|
"No category could be assigned to message " +
|
key + ". The category " +
|
"must either be encoded in the property key or " +
|
"or must be set by including the property " +
|
GLOBAL_CATEGORY + " in the properties file" +
|
KEY_FORM_MSG);
|
}
|
|
if (s == null) {
|
throw new BuildException(
|
"No severity could be assigned to message " +
|
key + ". The severity " +
|
"must either be encoded in the property key or " +
|
"or must be set by including the property " +
|
GLOBAL_SEVERITY + " in the properties file" +
|
KEY_FORM_MSG);
|
}
|
|
if (globalOrdinal == null) {
|
Integer ordinal = key.getOrdinal();
|
if (usedOrdinals.contains(ordinal)) {
|
throw new BuildException(
|
"The ordinal value \'" + ordinal + "\' in key " +
|
key + " has been previously defined in " +
|
source + KEY_FORM_MSG);
|
} else {
|
usedOrdinals.add(ordinal);
|
}
|
}
|
|
if (writeLogRef) {
|
// Document only FATAL_ERROR and SEVERE_ERROR messages.
|
if (s.name().equalsIgnoreCase("FATAL_ERROR")
|
|| s.name().equalsIgnoreCase("SEVERE_ERROR")) {
|
MessageRefEntry entry =
|
new MessageRefEntry(
|
c,
|
s,
|
globalOrdinal != null ?
|
globalOrdinal :
|
key.getOrdinal(),
|
formatString.replaceAll("<", "<"));
|
messageRefEntries.add(entry);
|
}
|
} else {
|
message.setConstructorArguments(
|
"BASE",
|
quote(key.toString()),
|
globalMask != null ? globalMask.toString() : c.name(),
|
s.name(),
|
globalOrdinal != null ?
|
globalOrdinal.toString() :
|
key.getOrdinal().toString()
|
);
|
destWriter.println(message.toString());
|
destWriter.println();
|
}
|
|
// Keep track of when we use the generic descriptor
|
// so that we can report it later
|
if (message.useGenericMessageTypeClass()) {
|
usesOfGenericDescriptor++;
|
}
|
}
|
|
if (writeLogRef) {
|
if (messageRefEntries.isEmpty()) {
|
destWriter.println("<!-- No message for this category -->");
|
} else {
|
MessageRefCategory mrc =
|
new MessageRefCategory(globalCategory, messageRefEntries);
|
destWriter.println(mrc.toXML());
|
}
|
}
|
|
log(" Message Generated:" + keyMap.size(), Project.MSG_VERBOSE);
|
log(" MessageDescriptor.ArgN:" + usesOfGenericDescriptor,
|
Project.MSG_VERBOSE);
|
|
} else if (!writeLogRef) {
|
stubLine = stubLine.replace("${PACKAGE}", getPackage());
|
stubLine = stubLine.replace("${CLASS_NAME}",
|
dest.getName().substring(0, dest.getName().length() -
|
".java".length()));
|
stubLine = stubLine.replace("${BASE}", getBase());
|
|
String useMessageJarIfWebstart =
|
properties.getProperty(GLOBAL_USE_MESSAGE_JAR_IF_WEBSTART);
|
if ((useMessageJarIfWebstart != null) &&
|
("true".equalsIgnoreCase(useMessageJarIfWebstart) ||
|
"on".equalsIgnoreCase(useMessageJarIfWebstart) ||
|
"true".equalsIgnoreCase(useMessageJarIfWebstart)))
|
{
|
useMessageJarIfWebstart = "true";
|
}
|
else
|
{
|
useMessageJarIfWebstart = "false";
|
}
|
stubLine = stubLine.replace("${USE_MESSAGE_JAR_IF_WEBSTART}",
|
useMessageJarIfWebstart);
|
destWriter.println(stubLine);
|
}
|
}
|
|
registerMessageDescriptor(getMessageDescriptorFullClassName());
|
|
stubReader.close();
|
destWriter.close();
|
|
} catch (Exception e) {
|
// Don't leave a malformed file laying around. Delete
|
// it so it will be forced to be regenerated.
|
if (dest.exists()) {
|
dest.deleteOnExit();
|
}
|
e.printStackTrace();
|
throw new BuildException("Error processing " + source +
|
": " + e.getMessage());
|
} finally {
|
if (stubReader != null) {
|
try {
|
stubReader.close();
|
} catch (Exception e){
|
// ignore
|
}
|
}
|
if (destWriter != null) {
|
try {
|
destWriter.close();
|
} catch (Exception e){
|
// ignore
|
}
|
}
|
}
|
}
|
|
private String getMessageDescriptorFullClassName() {
|
return getPackage() + "." + getMessageDescriptorClassName();
|
}
|
|
private String getMessageDescriptorClassName() {
|
return dest.getName().substring(
|
0, dest.getName().length() - ".java".length());
|
}
|
|
private String getBase() {
|
String srcPath = unixifyPath(source.getAbsolutePath());
|
String base = srcPath.substring(srcPath.lastIndexOf("/") + 1,
|
srcPath.length() - ".properties".length());
|
return base;
|
}
|
|
private String getPackage() {
|
if (writeLogRef) { return "dummy.package.name"; }
|
|
String destPath = unixifyPath(dest.getAbsolutePath());
|
String msgJavaGenDir = unixifyPath(
|
getProject().getProperty("msg.javagen.dir"));
|
String c = destPath.substring(msgJavaGenDir.length()+1);
|
c = c.replace('/', '.');
|
c = c.substring(0, c.lastIndexOf(".")); // strip .java
|
c = c.substring(0, c.lastIndexOf(".")); // strip class name
|
return c;
|
}
|
|
static private String indent(int indent) {
|
char[] blankArray = new char[2 * indent];
|
Arrays.fill(blankArray, ' ');
|
return new String(blankArray);
|
}
|
|
static private String quote(String s) {
|
return new StringBuilder()
|
.append("\"")
|
.append(s)
|
.append("\"")
|
.toString();
|
}
|
|
static private String getShortClassName(Class<?> c) {
|
String name;
|
String fqName = c.getName();
|
int i = fqName.lastIndexOf('.');
|
if (i > 0) {
|
name = fqName.substring(i + 1);
|
} else {
|
name = fqName;
|
}
|
return name;
|
}
|
|
/**
|
* Writes a record in the messages registry for the specifed
|
* class name.
|
* @param descClassName name of the message descriptor class
|
* @return true if the class was acutally added to the registry;
|
* false indicates that the class was already present.
|
* @throws IOException if there is a problem with the file I/O
|
*/
|
private boolean registerMessageDescriptor(String descClassName)
|
throws IOException
|
{
|
boolean classAdded = false;
|
File registry = getRegistryFile();
|
if (!isDescriptorRegistered(descClassName)) {
|
FileOutputStream file = new FileOutputStream(registry,true);
|
DataOutputStream out = new DataOutputStream(file);
|
out.writeBytes(descClassName);
|
out.writeBytes("\n");
|
out.flush();
|
out.close();
|
}
|
return classAdded;
|
}
|
|
private boolean isDescriptorRegistered(String descClassName)
|
throws IOException
|
{
|
boolean isRegistered = false;
|
BufferedReader reader = new BufferedReader(
|
new FileReader(getRegistryFile()));
|
String line;
|
while(null != (line = reader.readLine())) {
|
if (line.trim().equals(descClassName.trim())) {
|
isRegistered = true;
|
break;
|
}
|
}
|
return isRegistered;
|
}
|
|
private File getRegistryFile() throws IOException {
|
File registry = new File(REGISTRY_FILE_NAME);
|
if (!registry.exists()) {
|
File parent = registry.getParentFile();
|
if (!parent.exists()) {
|
parent.mkdirs();
|
}
|
registry.createNewFile();
|
}
|
return registry;
|
}
|
|
private File getProjectBase() {
|
return getProject().getBaseDir();
|
}
|
|
private String unixifyPath(String path) {
|
return path.replace("\\", "/");
|
}
|
|
/*
|
* Returns the stub file ("resource/Messages.java.stub") from the appropriate
|
* location: ant or jar file.
|
*/
|
private InputStream getStubFile() {
|
InputStream result = null;
|
|
File stub = new File(getProjectBase(), MESSAGES_FILE_STUB);
|
if ( stub.exists() ) {
|
// this is the OpenDS's ant project calling
|
// Stub is located at OPENDS_ROOT/resource/Messages.java.stub
|
try {
|
result = new FileInputStream(stub);
|
} catch (FileNotFoundException e) {
|
// should neven happen
|
throw new BuildException("Unable to load template " +
|
MESSAGES_FILE_STUB + ": " + e.getMessage());
|
}
|
} else {
|
// this is the example plugin's ant project calling
|
// Stub is located at build-tools.jar:resource/Messages.java.stub
|
result = getClass().getResourceAsStream(MESSAGES_FILE_STUB);
|
}
|
|
return result;
|
}
|
|
/**
|
* For testing.
|
* @param args from command line
|
*/
|
public static void main(String[] args) {
|
File source = new File("src/messages/messages/tools.properties");
|
File dest = new File("/tmp/org/opends/XXX.java");
|
GenerateMessageFile gmf = new GenerateMessageFile();
|
|
if (args.length > 0 && args[0].equalsIgnoreCase("generateMessageReference"))
|
{
|
dest = new File("/tmp/tools-ref.xml");
|
gmf.setWriteLogRef(true);
|
}
|
|
gmf.setOverwrite(true);
|
gmf.setDestJava(dest);
|
gmf.setSourceProps(source);
|
gmf.execute();
|
}
|
|
}
|
