/*
* Copyright 2008 Brian Thomas Matthews
*
* 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.
*/
package com.btmatthews.maven.plugins.ldap.mojos;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import org.apache.maven.plugin.MojoExecutionException;
import netscape.ldap.LDAPAttribute;
import netscape.ldap.LDAPAttributeSet;
import netscape.ldap.LDAPConnection;
import netscape.ldap.LDAPEntry;
import netscape.ldap.LDAPException;
import netscape.ldap.util.LDIF;
import netscape.ldap.util.LDIFAddContent;
import netscape.ldap.util.LDIFAttributeContent;
import netscape.ldap.util.LDIFContent;
import netscape.ldap.util.LDIFModDNContent;
import netscape.ldap.util.LDIFModifyContent;
import netscape.ldap.util.LDIFRecord;
/**
* Implement the goal that loads a LDIF file.
*
* @author <a href="mailto:brian.matthews@btmatthews.com">Brian Matthews</a>
* @version 1.0
* @goal ldif-load
*/
public final class LDIFLoaderMojo
extends AbstractLDAPMojo
{
/**
* The LDIF files to be processed.
*
* @parameter
* @required
*/
private File[] ldapFiles;
/**
* Indicates if the plugin should continue if there is an error. The default
* is to halt on error.
*
* @parameter default-value="false"
*/
private boolean continueOnError;
/**
* The default constructor.
*/
public LDIFLoaderMojo()
{
}
/**
* Execute the plugin goal.
*
* @throws MojoExecutionException
* If something unexpected happens.
*/
public void execute()
throws MojoExecutionException
{
// Connect to the LDAP server
final LDAPConnection connection = this.connect();
// Process the LDIF files
try
{
for (int i = 0; i < this.ldapFiles.length; ++i)
{
try
{
this.getLog().info("Processing " + this.ldapFiles[i]);
final InputStream inputStream = new FileInputStream(
this.ldapFiles[i]);
final DataInputStream dataInputStream = new DataInputStream(
inputStream);
final LDIF ldif = new LDIF(dataInputStream);
LDIFRecord record = ldif.nextRecord();
while (record != null)
{
this.processRecord(connection, record);
record = ldif.nextRecord();
}
}
catch (LDAPException e)
{
if (!this.continueOnError)
{
throw new MojoExecutionException("Error processing: "
+ this.ldapFiles[i], e);
}
else
{
this.getLog().warn(
"Ignoring error processing: " + this.ldapFiles[i],
e);
}
}
catch (FileNotFoundException e)
{
if (!this.continueOnError)
{
throw new MojoExecutionException("File not found: "
+ this.ldapFiles[i], e);
}
else
{
this.getLog().warn(
"Skipping missing file: " + this.ldapFiles[i], e);
}
}
catch (IOException e)
{
if (!this.continueOnError)
{
throw new MojoExecutionException("Error reading from: "
+ this.ldapFiles[i], e);
}
else
{
this.getLog()
.warn(
"Ignoring error reading from: "
+ this.ldapFiles[i], e);
}
}
}
}
finally
{
// Disconnect from the LDAP Server
try
{
connection.disconnect();
}
catch (LDAPException e)
{
this.getLog().warn(
"Ignoring error disconnecting from the LDAP server", e);
}
}
}
/**
* Process a parsed LDIF record. Delegate to the appropriate handler for
* each operation.
*
* @param connection
* The connection to the LDAP server.
* @param record
* The parsed record.
* @throws LDAPException
* If there was an LDAP error.
*/
private void processRecord(final LDAPConnection connection,
final LDIFRecord record)
throws LDAPException
{
final LDIFContent content = record.getContent();
final int contentType = content.getType();
switch (contentType)
{
case LDIFContent.MODDN_CONTENT:
this.renameEntry(connection, record.getDN(),
(LDIFModDNContent)content);
break;
case LDIFContent.MODIFICATION_CONTENT:
this.modifyEntry(connection, record.getDN(),
(LDIFModifyContent)content);
break;
case LDIFContent.DELETE_CONTENT:
this.deleteEntry(connection, record.getDN());
break;
case LDIFContent.ADD_CONTENT:
this.addEntry(connection, record.getDN(),
((LDIFAddContent)content).getAttributes());
break;
default:
this.addEntry(connection, record.getDN(),
((LDIFAttributeContent)content).getAttributes());
break;
}
}
/**
* Handle an LDIF add record.
*
* @param connection
* The connection to the LDAP server.
* @param entryDn
* The distinguished name of the record being added.
* @param attributes
* The attributes.
* @throws LDAPException
* If the operation failed.
*/
private void addEntry(final LDAPConnection connection,
final String entryDn, final LDAPAttribute[] attributes)
throws LDAPException
{
this.getLog().info("Add Entry: " + entryDn);
final LDAPAttributeSet attributeSet = new LDAPAttributeSet(attributes);
final LDAPEntry entry = new LDAPEntry(entryDn, attributeSet);
connection.add(entry);
}
/**
* Handle an LDIF delete record.
*
* @param connection
* The connection to the LDAP server.
* @param entryDn
* The distinguished name of the record to be deleted.
* @throws LDAPException
* If the operation failed.
*/
private void deleteEntry(final LDAPConnection connection,
final String entryDn)
throws LDAPException
{
this.getLog().info("Deleting " + entryDn);
connection.delete(entryDn);
}
/**
* Handle an LDIF modification record.
*
* @param connection
* The connection to the LDAP server.
* @param entryDn
* The distinguished name of the record being modified.
* @param content
* The details of the modification operation.
* @throws LDAPException
* If the operation failed.
*/
private void modifyEntry(final LDAPConnection connection,
final String entryDn, final LDIFModifyContent content)
throws LDAPException
{
this.getLog().info("Modify Entry: " + entryDn);
connection.modify(entryDn, content.getModifications());
}
/**
* Handle a LDIF distinguished name change operation.
*
* @param connection
* The connection to the LDAP server.
* @param entryDn
* The distinguished name of the record being renamed.
* @param content
* The details of the name change operation.
* @throws LDAPException
* If the operation failed.
*/
private void renameEntry(final LDAPConnection connection,
final String entryDn, final LDIFModDNContent content)
throws LDAPException
{
this.getLog().info("Rename Entry: " + entryDn);
connection.rename(entryDn, content.getRDN(), content.getNewParent(),
content.getDeleteOldRDN());
}
}