/// <summary>Finalize a log segment.</summary>
/// <remarks>
/// Finalize a log segment. If the journal manager is currently
/// writing to a ledger, ensure that this is the ledger of the log segment
/// being finalized.
/// Otherwise this is the recovery case. In the recovery case, ensure that
/// the firstTxId of the ledger matches firstTxId for the segment we are
/// trying to finalize.
/// </remarks>
/// <exception cref="System.IO.IOException"/>
public override void FinalizeLogSegment(long firstTxId, long lastTxId)
{
CheckEnv();
string inprogressPath = InprogressZNode(firstTxId);
try
{
Stat inprogressStat = zkc.Exists(inprogressPath, false);
if (inprogressStat == null)
{
throw new IOException("Inprogress znode " + inprogressPath + " doesn't exist");
}
EditLogLedgerMetadata l = EditLogLedgerMetadata.Read(zkc, inprogressPath);
if (currentLedger != null)
{
// normal, non-recovery case
if (l.GetLedgerId() == currentLedger.GetId())
{
try
{
currentLedger.Close();
}
catch (BKException bke)
{
Log.Error("Error closing current ledger", bke);
}
currentLedger = null;
}
else
{
throw new IOException("Active ledger has different ID to inprogress. " + l.GetLedgerId
() + " found, " + currentLedger.GetId() + " expected");
}
}
if (l.GetFirstTxId() != firstTxId)
{
throw new IOException("Transaction id not as expected, " + l.GetFirstTxId() + " found, "
+ firstTxId + " expected");
}
l.FinalizeLedger(lastTxId);
string finalisedPath = FinalizedLedgerZNode(firstTxId, lastTxId);
try
{
l.Write(zkc, finalisedPath);
}
catch (KeeperException.NodeExistsException)
{
if (!l.Verify(zkc, finalisedPath))
{
throw new IOException("Node " + finalisedPath + " already exists" + " but data doesn't match"
);
}
}
maxTxId.Store(lastTxId);
zkc.Delete(inprogressPath, inprogressStat.GetVersion());
string inprogressPathFromCI = ci.Read();
if (inprogressPath.Equals(inprogressPathFromCI))
{
ci.Clear();
}
}
catch (KeeperException e)
{
throw new IOException("Error finalising ledger", e);
}
catch (Exception ie)
{
Sharpen.Thread.CurrentThread().Interrupt();
throw new IOException("Error finalising ledger", ie);
}
}
/// <summary>Start a new log segment in a BookKeeper ledger.</summary>
/// <remarks>
/// Start a new log segment in a BookKeeper ledger.
/// First ensure that we have the write lock for this journal.
/// Then create a ledger and stream based on that ledger.
/// The ledger id is written to the inprogress znode, so that in the
/// case of a crash, a recovery process can find the ledger we were writing
/// to when we crashed.
/// </remarks>
/// <param name="txId">First transaction id to be written to the stream</param>
/// <exception cref="System.IO.IOException"/>
public override EditLogOutputStream StartLogSegment(long txId, int layoutVersion)
{
CheckEnv();
if (txId <= maxTxId.Get())
{
throw new IOException("We've already seen " + txId + ". A new stream cannot be created with it"
);
}
try
{
string existingInprogressNode = ci.Read();
if (null != existingInprogressNode && zkc.Exists(existingInprogressNode, false) !=
null)
{
throw new IOException("Inprogress node already exists");
}
if (currentLedger != null)
{
// bookkeeper errored on last stream, clean up ledger
currentLedger.Close();
}
currentLedger = bkc.CreateLedger(ensembleSize, quorumSize, ackQuorumSize, BookKeeper.DigestType
.Mac, Sharpen.Runtime.GetBytesForString(digestpw, Charsets.Utf8));
}
catch (BKException bke)
{
throw new IOException("Error creating ledger", bke);
}
catch (KeeperException ke)
{
throw new IOException("Error in zookeeper while creating ledger", ke);
}
catch (Exception ie)
{
Sharpen.Thread.CurrentThread().Interrupt();
throw new IOException("Interrupted creating ledger", ie);
}
try
{
string znodePath = InprogressZNode(txId);
EditLogLedgerMetadata l = new EditLogLedgerMetadata(znodePath, layoutVersion, currentLedger
.GetId(), txId);
/* Write the ledger metadata out to the inprogress ledger znode
* This can fail if for some reason our write lock has
* expired (@see WriteLock) and another process has managed to
* create the inprogress znode.
* In this case, throw an exception. We don't want to continue
* as this would lead to a split brain situation.
*/
l.Write(zkc, znodePath);
maxTxId.Store(txId);
ci.Update(znodePath);
return(new BookKeeperEditLogOutputStream(conf, currentLedger));
}
catch (KeeperException ke)
{
CleanupLedger(currentLedger);
throw new IOException("Error storing ledger metadata", ke);
}
}
