JEChangeNumberIndexDB.java revision 90f97a8328fb2433989b4ac05dd565dc6b4db4bc
/*
* 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 legal-notices/CDDLv1_0.txt
* 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 legal-notices/CDDLv1_0.txt.
* 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 2009-2010 Sun Microsystems, Inc.
* Portions Copyright 2011-2015 ForgeRock AS
*/
/**
* This class is used for managing the replicationServer database for each
* server in the topology. It is responsible for efficiently saving the updates
* that is received from each master server into stable storage. This class is
* also able to generate a {@link DBCursor} that can be used to read all changes
* from a given change number.
* <p>
* This class publishes some monitoring information below <code>
* cn=monitor</code>.
*/
public class JEChangeNumberIndexDB implements ChangeNumberIndexDB
{
private static final int NO_KEY = 0;
/**
* The newest changenumber stored in the DB. It is used to avoid purging the
* record with the newest changenumber. The newest record in the changenumber
* index DB is used to persist the {@link #lastGeneratedChangeNumber} which is
* then retrieved on server startup.
*/
private volatile long newestChangeNumber = NO_KEY;
/**
* The last generated value for the change number. It is kept separate from
* the {@link #newestChangeNumber} because there is an opportunity for a race
* condition between:
* <ol>
* <li>this atomic long being incremented for a new record ('recordB')</li>
* <li>the current newest record ('recordA') being purged from the DB</li>
* <li>'recordB' failing to be inserted in the DB</li>
* </ol>
*/
private final AtomicLong lastGeneratedChangeNumber;
/**
* Creates a new JEChangeNumberIndexDB associated to a given LDAP server.
*
* @param dbEnv the Database Env to use to create the ReplicationServer DB.
* server for this domain.
* @throws ChangelogException If a database problem happened
*/
{
// initialization of the lastGeneratedChangeNumber from the DB content
// if DB is empty => last record does not exist => default to 0
// Monitoring registration
}
throws ChangelogException
{
{
return record.getChangeNumber();
}
return NO_KEY;
}
/** {@inheritDoc} */
throws ChangelogException
{
long changeNumber = nextChangeNumber();
final ChangeNumberIndexRecord newRecord =
return changeNumber;
}
/** {@inheritDoc} */
{
return db.readFirstRecord();
}
/** {@inheritDoc} */
{
return db.readLastRecord();
}
private long nextChangeNumber()
{
return lastGeneratedChangeNumber.incrementAndGet();
}
/** {@inheritDoc} */
public long getLastGeneratedChangeNumber()
{
return lastGeneratedChangeNumber.get();
}
/**
* Get the number of changes.
* @return Returns the number of changes.
*/
public long count()
{
}
/**
* Returns whether this database is empty.
*
* @return <code>true</code> if this database is empty, <code>false</code>
* otherwise
* @throws ChangelogException
* if a database problem occurs.
*/
public boolean isEmpty() throws ChangelogException
{
return getNewestRecord() == null;
}
/** {@inheritDoc} */
throws ChangelogException
{
}
/**
* Shutdown this DB.
*/
public void shutdown()
{
if (shutdown.compareAndSet(false, true))
{
}
}
/**
* Synchronously purges the change number index DB up to and excluding the
* provided timestamp.
*
* @param purgeCSN
* the timestamp up to which purging must happen
* @return the oldest non purged CSN.
* @throws ChangelogException
* if a database problem occurs.
*/
{
{
return null;
}
try
{
{
{
}
else
{
// 1- Current record is not old enough to purge.
// 2- Do not purge the newest record to avoid having the last
// generated changenumber dropping back to 0 when the server restarts
}
}
return null;
}
catch (ChangelogException e)
{
throw e;
}
catch (Exception e)
{
throw new ChangelogException(e);
}
finally
{
}
}
/**
* Clear the changes from this DB (from both memory cache and DB storage) for
* the provided baseDN.
*
* @param baseDNToClear
* The baseDN for which we want to remove all records from this DB,
* null means all.
* @throws ChangelogException
* if a database problem occurs.
*/
{
if (isEmpty())
{
return;
}
try
{
{
{
// do not purge the newest record to avoid having the last generated
// changenumber dropping back to 0 if the server restarts
return;
}
{
}
}
}
catch (ChangelogException e)
{
throw e;
}
finally
{
}
}
{
}
/**
* This internal class is used to implement the Monitoring capabilities of the
* JEChangeNumberIndexDB.
*/
{
/** {@inheritDoc} */
{
return attributes;
}
{
final String attributeName =
}
private long readChangeNumber(boolean isFirst)
{
try
{
return getChangeNumber(
}
catch (ChangelogException e)
{
logger.traceException(e);
return NO_KEY;
}
}
/** {@inheritDoc} */
public String getMonitorInstanceName()
{
return "ChangeNumber Index Database";
}
/** {@inheritDoc} */
{
// Nothing to do for now
}
}
/** {@inheritDoc} */
{
}
/**
* Clear the changes from this DB (from both memory cache and DB storage).
*
* @throws ChangelogException
* if a database problem occurs.
*/
public void clear() throws ChangelogException
{
}
public void resetChangeNumberTo(long newFirstCN, DN baseDN, CSN newFirstCSN) throws ChangelogException
{
}
}