com.btmatthews.maven.plugins.ldap.mojos.LDIFLoaderMojo Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ldap-maven-plugin Show documentation
Parse and load LDIF records to an LDAP directory server. Dump records from an LDAP directory server to LDIF or DSML formats.
The newest version!
/*
 * 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 Brian Matthews
 * @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());
    }
}