/*
* 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 2006-2009 Sun Microsystems, Inc.
* Portions Copyright 2013 ForgeRock AS.
*/
package org.opends.server.util;
import java.io.BufferedWriter;
import java.io.Closeable;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.regex.Pattern;
import java.util.Collection;
import org.opends.messages.Message;
import org.opends.server.tools.makeldif.TemplateEntry;
import org.opends.server.types.*;
import static org.opends.server.util.StaticUtils.*;
import static org.opends.server.util.Validator.*;
/**
* This class provides a mechanism for writing entries in LDIF form to a file or
* an output stream.
*/
@org.opends.server.types.PublicAPI(
stability=org.opends.server.types.StabilityLevel.UNCOMMITTED,
mayInstantiate=true,
mayExtend=false,
mayInvoke=true)
public final class LDIFWriter implements Closeable
{
// FIXME -- Add support for generating a hash when writing the data.
// FIXME -- Add support for signing the hash that is generated.
// The writer to which the LDIF information will be written.
private BufferedWriter writer;
// The configuration to use for the export.
private LDIFExportConfig exportConfig;
// Regular expression used for splitting comments on line-breaks.
private static final Pattern SPLIT_NEWLINE = Pattern.compile("\\r?\\n");
/**
* Creates a new LDIF writer with the provided configuration.
*
* @param exportConfig The configuration to use for the export. It must not
* be <CODE>null</CODE>.
*
* @throws IOException If a problem occurs while opening the writer.
*/
public LDIFWriter(LDIFExportConfig exportConfig)
throws IOException
{
ensureNotNull(exportConfig);
this.exportConfig = exportConfig;
writer = exportConfig.getWriter();
}
/**
* Writes the provided comment to the LDIF file, optionally wrapping near the
* specified column. Each line will be prefixed by the octothorpe (#)
* character followed by a space. If the comment should be wrapped at a
* specified column, then it will attempt to do so at the first whitespace
* character at or before that column (so it will try not wrap in the middle
* of a word).
* <BR><BR>
* This comment will be ignored by the
* Directory Server's LDIF reader, as well as any other compliant LDIF parsing
* software.
*
* @param comment The comment to be written. Any line breaks that it
* contains will be honored, and potentially new line
* breaks may be introduced by the wrapping process. It
* must not be <CODE>null</CODE>.
* @param wrapColumn The column at which long lines should be wrapped, or
* -1 to indicate that no additional wrapping should be
* added. This will override the wrap column setting
* specified in the LDIF export configuration.
*
* @throws IOException If a problem occurs while attempting to write the
* comment to the LDIF file.
*/
public void writeComment(Message comment, int wrapColumn)
throws IOException
{
ensureNotNull(comment);
// First, break up the comment into multiple lines to preserve the original
// spacing that it contained.
String[] lines = SPLIT_NEWLINE.split(comment);
// Now iterate through the lines and write them out, prefixing and wrapping
// them as necessary.
for (String l : lines)
{
if (wrapColumn <= 0)
{
writer.write("# ");
writer.write(l);
writer.newLine();
}
else
{
int breakColumn = wrapColumn - 2;
if (l.length() <= breakColumn)
{
writer.write("# ");
writer.write(l);
writer.newLine();
}
else
{
int startPos = 0;
outerLoop:
while (startPos < l.length())
{
if ((startPos+breakColumn) >= l.length())
{
writer.write("# ");
writer.write(l.substring(startPos));
writer.newLine();
startPos = l.length();
}
else
{
int endPos = startPos + breakColumn;
int i=endPos - 1;
while (i > startPos)
{
if (l.charAt(i) == ' ')
{
writer.write("# ");
writer.write(l.substring(startPos, i));
writer.newLine();
startPos = i+1;
continue outerLoop;
}
i--;
}
// If we've gotten here, then there are no spaces on the entire
// line. If that happens, then we'll have to break in the middle
// of a word.
writer.write("# ");
writer.write(l.substring(startPos, endPos));
writer.newLine();
startPos = endPos;
}
}
}
}
}
}
/**
* Iterates over each entry contained in the map and writes out the entry in
* LDIF format. The main benefit of this method is that the entries can be
* sorted by DN and output in sorted order.
*
* @param entries The Map containing the entries keyed by DN.
*
* @return <CODE>true</CODE>of all of the entries were
* written out, <CODE>false</CODE>if it was not
* because of the export configuration.
*
* @throws IOException If a problem occurs while writing the entry to LDIF.
*
* @throws LDIFException If a problem occurs while trying to determine
* whether to include the entry in the export.
*/
public boolean writeEntries(Collection <Entry> entries)
throws IOException, LDIFException {
boolean ret=true;
Iterator<Entry> i = entries.iterator();
while(ret && i.hasNext()) {
ret=writeEntry(i.next());
}
return ret;
}
/**
* Writes the provided entry to LDIF.
*
* @param entry The entry to be written. It must not be <CODE>null</CODE>.
*
* @return <CODE>true</CODE> if the entry was actually written, or
* <CODE>false</CODE> if it was not because of the export
* configuration.
*
* @throws IOException If a problem occurs while writing the entry to LDIF.
*
* @throws LDIFException If a problem occurs while trying to determine
* whether to include the entry in the export.
*/
public boolean writeEntry(Entry entry)
throws IOException, LDIFException
{
ensureNotNull(entry);
return entry.toLDIF(exportConfig);
}
/**
* Writes the provided template entry to LDIF.
*
* @param templateEntry The template entry to be written. It must not be
* <CODE>null</CODE>.
*
* @return <CODE>true</CODE> if the entry was actually written, or
* <CODE>false</CODE> if it was not because of the export
* configuration.
*
* @throws IOException If a problem occurs while writing the template entry
* to LDIF.
*
* @throws LDIFException If a problem occurs while trying to determine
* whether to include the template entry in the
* export.
*/
public boolean writeTemplateEntry(TemplateEntry templateEntry)
throws IOException, LDIFException
{
ensureNotNull(templateEntry);
// Delegate to TemplateEntry.toLDIF(...)
return templateEntry.toLDIF(exportConfig);
}
/**
* Writes a change record entry for the provided change record.
*
* @param changeRecord The change record entry to be written.
*
* @throws IOException If a problem occurs while writing the change record.
*/
public void writeChangeRecord(ChangeRecordEntry changeRecord)
throws IOException
{
ensureNotNull(changeRecord);
// Get the information necessary to write the LDIF.
BufferedWriter writer = exportConfig.getWriter();
int wrapColumn = exportConfig.getWrapColumn();
boolean wrapLines = (wrapColumn > 1);
// First, write the DN.
StringBuilder dnLine = new StringBuilder();
dnLine.append("dn");
appendLDIFSeparatorAndValue(dnLine,
ByteString.valueOf(changeRecord.getDN().toString()));
writeLDIFLine(dnLine, writer, wrapLines, wrapColumn);
// Figure out what type of change it is and act accordingly.
if (changeRecord instanceof AddChangeRecordEntry)
{
StringBuilder changeTypeLine = new StringBuilder("changetype: add");
writeLDIFLine(changeTypeLine, writer, wrapLines, wrapColumn);
AddChangeRecordEntry addRecord = (AddChangeRecordEntry) changeRecord;
for (Attribute a : addRecord.getAttributes())
{
for (AttributeValue v : a)
{
StringBuilder line = new StringBuilder();
line.append(a.getNameWithOptions());
appendLDIFSeparatorAndValue(line, v.getValue());
writeLDIFLine(line, writer, wrapLines, wrapColumn);
}
}
}
else if (changeRecord instanceof DeleteChangeRecordEntry)
{
StringBuilder changeTypeLine = new StringBuilder("changetype: delete");
writeLDIFLine(changeTypeLine, writer, wrapLines, wrapColumn);
}
else if (changeRecord instanceof ModifyChangeRecordEntry)
{
StringBuilder changeTypeLine = new StringBuilder("changetype: modify");
writeLDIFLine(changeTypeLine, writer, wrapLines, wrapColumn);
ModifyChangeRecordEntry modifyRecord =
(ModifyChangeRecordEntry) changeRecord;
List<RawModification> mods = modifyRecord.getModifications();
Iterator<RawModification> iterator = mods.iterator();
while (iterator.hasNext())
{
RawModification m = iterator.next();
RawAttribute a = m.getAttribute();
String attrName = a.getAttributeType();
StringBuilder modTypeLine = new StringBuilder();
modTypeLine.append(m.getModificationType().getLDIFName());
modTypeLine.append(": ");
modTypeLine.append(attrName);
writeLDIFLine(modTypeLine, writer, wrapLines, wrapColumn);
for (ByteString s : a.getValues())
{
StringBuilder valueLine = new StringBuilder();
String stringValue = s.toString();
valueLine.append(attrName);
if (needsBase64Encoding(stringValue))
{
valueLine.append(":: ");
valueLine.append(Base64.encode(s));
}
else
{
valueLine.append(": ");
valueLine.append(stringValue);
}
writeLDIFLine(valueLine, writer, wrapLines, wrapColumn);
}
if (iterator.hasNext())
{
StringBuilder dashLine = new StringBuilder("-");
writeLDIFLine(dashLine, writer, wrapLines, wrapColumn);
}
}
}
else if (changeRecord instanceof ModifyDNChangeRecordEntry)
{
StringBuilder changeTypeLine = new StringBuilder("changetype: moddn");
writeLDIFLine(changeTypeLine, writer, wrapLines, wrapColumn);
ModifyDNChangeRecordEntry modifyDNRecord =
(ModifyDNChangeRecordEntry) changeRecord;
StringBuilder newRDNLine = new StringBuilder();
newRDNLine.append("newrdn: ");
modifyDNRecord.getNewRDN().toString(newRDNLine);
writeLDIFLine(newRDNLine, writer, wrapLines, wrapColumn);
StringBuilder deleteOldRDNLine = new StringBuilder();
deleteOldRDNLine.append("deleteoldrdn: ");
if (modifyDNRecord.deleteOldRDN())
{
deleteOldRDNLine.append("1");
}
else
{
deleteOldRDNLine.append("0");
}
writeLDIFLine(deleteOldRDNLine, writer, wrapLines, wrapColumn);
DN newSuperiorDN = modifyDNRecord.getNewSuperiorDN();
if (newSuperiorDN != null)
{
StringBuilder newSuperiorLine = new StringBuilder();
newSuperiorLine.append("newsuperior: ");
newSuperiorDN.toString(newSuperiorLine);
writeLDIFLine(newSuperiorLine, writer, wrapLines, wrapColumn);
}
}
// Make sure there is a blank line after the entry.
writer.newLine();
}
/**
* Writes an add change record for the provided entry. No filtering will be
* performed for this entry, nor will any export plugins be invoked. Further,
* only the user attributes will be included.
*
* @param entry The entry to include in the add change record. It must not
* be <CODE>null</CODE>.
*
* @throws IOException If a problem occurs while writing the add record.
*/
public void writeAddChangeRecord(Entry entry)
throws IOException
{
ensureNotNull(entry);
// Get the information necessary to write the LDIF.
BufferedWriter writer = exportConfig.getWriter();
int wrapColumn = exportConfig.getWrapColumn();
boolean wrapLines = (wrapColumn > 1);
// First, write the DN.
StringBuilder dnLine = new StringBuilder();
dnLine.append("dn");
appendLDIFSeparatorAndValue(dnLine,
ByteString.valueOf(entry.getDN().toString()));
writeLDIFLine(dnLine, writer, wrapLines, wrapColumn);
// Next, the changetype.
StringBuilder changeTypeLine = new StringBuilder("changetype: add");
writeLDIFLine(changeTypeLine, writer, wrapLines, wrapColumn);
// Now the objectclasses.
for (String s : entry.getObjectClasses().values())
{
StringBuilder ocLine = new StringBuilder();
ocLine.append("objectClass: ");
ocLine.append(s);
writeLDIFLine(ocLine, writer, wrapLines, wrapColumn);
}
// Finally, the set of user attributes.
for (AttributeType attrType : entry.getUserAttributes().keySet())
{
List<Attribute> attrList = entry.getUserAttribute(attrType);
for (Attribute a : attrList)
{
StringBuilder attrName = new StringBuilder(a.getName());
for (String o : a.getOptions())
{
attrName.append(";");
attrName.append(o);
}
for (AttributeValue v : a)
{
StringBuilder attrLine = new StringBuilder();
attrLine.append(attrName);
appendLDIFSeparatorAndValue(attrLine, v.getValue());
writeLDIFLine(attrLine, writer, wrapLines, wrapColumn);
}
}
}
// Make sure there is a blank line after the entry.
writer.newLine();
}
/**
* Writes a delete change record for the provided entry, optionally including
* a comment with the full entry contents. No filtering will be performed for
* this entry, nor will any export plugins be invoked. Further, only the user
* attributes will be included.
*
* @param entry The entry to include in the delete change record. It
* must not be <CODE>null</CODE>.
* @param commentEntry Indicates whether to include a comment with the
* contents of the entry.
*
* @throws IOException If a problem occurs while writing the delete record.
*/
public void writeDeleteChangeRecord(Entry entry, boolean commentEntry)
throws IOException
{
ensureNotNull(entry);
// Get the information necessary to write the LDIF.
BufferedWriter writer = exportConfig.getWriter();
int wrapColumn = exportConfig.getWrapColumn();
boolean wrapLines = (wrapColumn > 1);
// Add the DN and changetype lines.
StringBuilder dnLine = new StringBuilder();
dnLine.append("dn");
appendLDIFSeparatorAndValue(dnLine,
ByteString.valueOf(entry.getDN().toString()));
writeLDIFLine(dnLine, writer, wrapLines, wrapColumn);
StringBuilder changeTypeLine = new StringBuilder("changetype: delete");
writeLDIFLine(changeTypeLine, writer, wrapLines, wrapColumn);
// If we should include a comment with the rest of the entry contents, then
// do so now.
if (commentEntry)
{
// Write the objectclasses.
for (String s : entry.getObjectClasses().values())
{
StringBuilder ocLine = new StringBuilder();
ocLine.append("# objectClass: ");
ocLine.append(s);
writeLDIFLine(ocLine, writer, wrapLines, wrapColumn);
}
// Write the set of user attributes.
for (AttributeType attrType : entry.getUserAttributes().keySet())
{
List<Attribute> attrList = entry.getUserAttribute(attrType);
for (Attribute a : attrList)
{
StringBuilder attrName = new StringBuilder();
attrName.append("# ");
attrName.append(a.getName());
for (String o : a.getOptions())
{
attrName.append(";");
attrName.append(o);
}
for (AttributeValue v : a)
{
StringBuilder attrLine = new StringBuilder();
attrLine.append(attrName);
appendLDIFSeparatorAndValue(attrLine, v.getValue());
writeLDIFLine(attrLine, writer, wrapLines, wrapColumn);
}
}
}
}
// Make sure there is a blank line after the entry.
writer.newLine();
}
/**
* Writes a modify change record with the provided information. No filtering
* will be performed, nor will any export plugins be invoked.
*
* @param dn The DN of the entry being modified. It must not be
* <CODE>null</CODE>.
* @param modifications The set of modifications to include in the change
* record. It must not be <CODE>null</CODE>.
*
* @throws IOException If a problem occurs while writing the modify record.
*/
public void writeModifyChangeRecord(DN dn, List<Modification> modifications)
throws IOException
{
ensureNotNull(dn, modifications);
// If there aren't any modifications, then there's nothing to do.
if (modifications.isEmpty())
{
return;
}
// Get the information necessary to write the LDIF.
BufferedWriter writer = exportConfig.getWriter();
int wrapColumn = exportConfig.getWrapColumn();
boolean wrapLines = (wrapColumn > 1);
// Write the DN and changetype.
StringBuilder dnLine = new StringBuilder();
dnLine.append("dn");
appendLDIFSeparatorAndValue(dnLine, ByteString.valueOf(dn.toString()));
writeLDIFLine(dnLine, writer, wrapLines, wrapColumn);
StringBuilder changeTypeLine = new StringBuilder("changetype: modify");
writeLDIFLine(changeTypeLine, writer, wrapLines, wrapColumn);
// Iterate through the modifications and write them to the LDIF.
Iterator<Modification> iterator = modifications.iterator();
while (iterator.hasNext())
{
Modification m = iterator.next();
Attribute a = m.getAttribute();
StringBuilder nameBuffer = new StringBuilder(a.getName());
for (String o : a.getOptions())
{
nameBuffer.append(";");
nameBuffer.append(o);
}
String name = nameBuffer.toString();
StringBuilder modTypeLine = new StringBuilder();
switch (m.getModificationType())
{
case ADD:
modTypeLine.append("add: ");
modTypeLine.append(name);
break;
case DELETE:
modTypeLine.append("delete: ");
modTypeLine.append(name);
break;
case REPLACE:
modTypeLine.append("replace: ");
modTypeLine.append(name);
break;
case INCREMENT:
modTypeLine.append("increment: ");
modTypeLine.append(name);
break;
default:
// We have no idea what the changetype is, so we can't write anything.
continue;
}
writeLDIFLine(modTypeLine, writer, wrapLines, wrapColumn);
for (AttributeValue v : a)
{
StringBuilder valueLine = new StringBuilder();
valueLine.append(name);
appendLDIFSeparatorAndValue(valueLine, v.getValue());
writeLDIFLine(valueLine, writer, wrapLines, wrapColumn);
}
// If this is the last modification, then append blank line. Otherwise
// write a line with just a dash.
if (iterator.hasNext())
{
writer.write("-");
writer.newLine();
}
else
{
writer.newLine();
}
}
}
/**
* Writes a modify DN change record with the provided information. No
* filtering will be performed, nor will any export plugins be invoked.
*
* @param dn The DN of the entry before the rename. It must not
* be <CODE>null</CODE>.
* @param newRDN The new RDN for the entry. It must not be
* <CODE>null</CODE>.
* @param deleteOldRDN Indicates whether the old RDN value should be removed
* from the entry.
* @param newSuperior The new superior DN for the entry, or
* <CODE>null</CODE> if the entry will stay below the
* same parent.
*
* @throws IOException If a problem occurs while writing the modify record.
*/
public void writeModifyDNChangeRecord(DN dn, RDN newRDN, boolean deleteOldRDN,
DN newSuperior)
throws IOException
{
ensureNotNull(dn, newRDN);
// Get the information necessary to write the LDIF.
BufferedWriter writer = exportConfig.getWriter();
int wrapColumn = exportConfig.getWrapColumn();
boolean wrapLines = (wrapColumn > 1);
// Write the current DN.
StringBuilder dnLine = new StringBuilder();
dnLine.append("dn");
appendLDIFSeparatorAndValue(dnLine, ByteString.valueOf(dn.toString()));
writeLDIFLine(dnLine, writer, wrapLines, wrapColumn);
// Write the changetype. Some older tools may not support the "moddn"
// changetype, so only use it if a newSuperior element has been provided,
// but use modrdn elsewhere.
if (newSuperior == null)
{
StringBuilder changeTypeLine = new StringBuilder("changetype: modrdn");
writeLDIFLine(changeTypeLine, writer, wrapLines, wrapColumn);
}
else
{
StringBuilder changeTypeLine = new StringBuilder("changetype: moddn");
writeLDIFLine(changeTypeLine, writer, wrapLines, wrapColumn);
}
// Write the newRDN element.
StringBuilder rdnLine = new StringBuilder();
rdnLine.append("newrdn");
appendLDIFSeparatorAndValue(rdnLine, ByteString.valueOf(newRDN.toString()));
writeLDIFLine(rdnLine, writer, wrapLines, wrapColumn);
// Write the deleteOldRDN element.
StringBuilder deleteOldRDNLine = new StringBuilder();
deleteOldRDNLine.append("deleteoldrdn: ");
deleteOldRDNLine.append(deleteOldRDN ? "1" : "0");
writeLDIFLine(deleteOldRDNLine, writer, wrapLines, wrapColumn);
if (newSuperior != null)
{
StringBuilder newSuperiorLine = new StringBuilder();
newSuperiorLine.append("newsuperior");
appendLDIFSeparatorAndValue(newSuperiorLine,
ByteString.valueOf(newSuperior.toString()));
writeLDIFLine(newSuperiorLine, writer, wrapLines, wrapColumn);
}
// Make sure there is a blank line after the entry.
writer.newLine();
}
/**
* Flushes the data written to the output stream or underlying file.
*
* @throws IOException If a problem occurs while flushing the output.
*/
public void flush()
throws IOException
{
writer.flush();
}
/**
* Closes the LDIF writer and the underlying output stream or file.
*
* @throws IOException If a problem occurs while closing the writer.
*/
public void close()
throws IOException
{
writer.flush();
writer.close();
}
/**
* Appends an LDIF separator and properly-encoded form of the given
* value to the provided buffer. If the value is safe to include
* as-is, then a single colon, a single space, space, and the
* provided value will be appended. Otherwise, two colons, a single
* space, and a base64-encoded form of the value will be appended.
*
* @param buffer The buffer to which the information should be
* appended. It must not be <CODE>null</CODE>.
* @param valueBytes The value to append to the buffer. It must not be
* <CODE>null</CODE>.
*/
public static void appendLDIFSeparatorAndValue(StringBuilder buffer,
ByteSequence valueBytes)
{
appendLDIFSeparatorAndValue(buffer, valueBytes, false, false);
}
/**
* Appends an LDIF separator and properly-encoded form of the given
* value to the provided buffer. If the value is safe to include
* as-is, then a single colon, a single space, space, and the
* provided value will be appended. Otherwise, two colons, a single
* space, and a base64-encoded form of the value will be appended.
* @param buffer The buffer to which the information should be
* appended. It must not be <CODE>null</CODE>.
* @param valueBytes The value to append to the buffer. It must not be
* <CODE>null</CODE>.
* @param isURL Whether the provided value is an URL value or not.
* @param isBase64 Whether the provided value is a base 64 value or not.
*/
public static void appendLDIFSeparatorAndValue(StringBuilder buffer,
ByteSequence valueBytes, boolean isURL, boolean isBase64)
{
ensureNotNull(buffer, valueBytes);
// If the value is empty, then just append a single colon (the URL '<' if
// required) and a single space.
if ((valueBytes == null) || (valueBytes.length() == 0))
{
if (isURL)
{
buffer.append(":< ");
}
else if (isBase64)
{
buffer.append(":: ");
}
else
{
buffer.append(": ");
}
return;
}
if (isURL)
{
buffer.append(":< ");
buffer.append(valueBytes.toString());
}
else if (isBase64)
{
buffer.append(":: ");
buffer.append(valueBytes.toString());
}
else if (needsBase64Encoding(valueBytes))
{
buffer.append(":: ");
buffer.append(Base64.encode(valueBytes));
}
else
{
buffer.append(": ");
buffer.append(valueBytes.toString());
}
}
/**
* Writes the provided line to LDIF using the provided information.
*
* @param line The line of information to write. It must not be
* <CODE>null</CODE>.
* @param writer The writer to which the data should be written. It
* must not be <CODE>null</CODE>.
* @param wrapLines Indicates whether to wrap long lines.
* @param wrapColumn The column at which long lines should be wrapped.
*
* @throws IOException If a problem occurs while writing the information.
*/
public static void writeLDIFLine(StringBuilder line, BufferedWriter writer,
boolean wrapLines, int wrapColumn)
throws IOException
{
ensureNotNull(line, writer);
int length = line.length();
if (wrapLines && (length > wrapColumn))
{
writer.write(line.substring(0, wrapColumn));
writer.newLine();
int pos = wrapColumn;
while (pos < length)
{
int writeLength = Math.min(wrapColumn-1, length-pos);
writer.write(' ');
writer.write(line.substring(pos, pos+writeLength));
writer.newLine();
pos += wrapColumn-1;
}
}
else
{
writer.write(line.toString());
writer.newLine();
}
}
}