/// <exception cref="System.IO.IOException"/>
public override void RecoverUnfinalizedSegments()
{
CheckEnv();
lock (this)
{
try
{
IList <string> children = zkc.GetChildren(ledgerPath, false);
foreach (string child in children)
{
if (!child.StartsWith(BkjmEditInprogress))
{
continue;
}
string znode = ledgerPath + "/" + child;
EditLogLedgerMetadata l = EditLogLedgerMetadata.Read(zkc, znode);
try
{
long endTxId = RecoverLastTxId(l, true);
if (endTxId == HdfsConstants.InvalidTxid)
{
Log.Error("Unrecoverable corruption has occurred in segment " + l.ToString() + " at path "
+ znode + ". Unable to continue recovery.");
throw new IOException("Unrecoverable corruption," + " please check logs.");
}
FinalizeLogSegment(l.GetFirstTxId(), endTxId);
}
catch (BookKeeperJournalManager.SegmentEmptyException)
{
Log.Warn("Inprogress znode " + child + " refers to a ledger which is empty. This occurs when the NN"
+ " crashes after opening a segment, but before writing the" + " OP_START_LOG_SEGMENT op. It is safe to delete."
+ " MetaData [" + l.ToString() + "]");
// If the max seen transaction is the same as what would
// have been the first transaction of the failed ledger,
// decrement it, as that transaction never happened and as
// such, is _not_ the last seen
if (maxTxId.Get() == l.GetFirstTxId())
{
maxTxId.Reset(maxTxId.Get() - 1);
}
zkc.Delete(znode, -1);
}
}
}
catch (KeeperException.NoNodeException)
{
}
catch (KeeperException ke)
{
// nothing to recover, ignore
throw new IOException("Couldn't get list of inprogress segments", ke);
}
catch (Exception ie)
{
Sharpen.Thread.CurrentThread().Interrupt();
throw new IOException("Interrupted getting list of inprogress segments", ie);
}
}
}
/// <summary>
/// Find the id of the last edit log transaction writen to a edit log
/// ledger.
/// </summary>
/// <exception cref="System.IO.IOException"/>
/// <exception cref="Org.Apache.Hadoop.Contrib.Bkjournal.BookKeeperJournalManager.SegmentEmptyException
/// "/>
private long RecoverLastTxId(EditLogLedgerMetadata l, bool fence)
{
LedgerHandle lh = null;
try
{
if (fence)
{
lh = bkc.OpenLedger(l.GetLedgerId(), BookKeeper.DigestType.Mac, Sharpen.Runtime.GetBytesForString
(digestpw, Charsets.Utf8));
}
else
{
lh = bkc.OpenLedgerNoRecovery(l.GetLedgerId(), BookKeeper.DigestType.Mac, Sharpen.Runtime.GetBytesForString
(digestpw, Charsets.Utf8));
}
}
catch (BKException bke)
{
throw new IOException("Exception opening ledger for " + l, bke);
}
catch (Exception ie)
{
Sharpen.Thread.CurrentThread().Interrupt();
throw new IOException("Interrupted opening ledger for " + l, ie);
}
BookKeeperEditLogInputStream @in = null;
try
{
long lastAddConfirmed = lh.GetLastAddConfirmed();
if (lastAddConfirmed == -1)
{
throw new BookKeeperJournalManager.SegmentEmptyException();
}
@in = new BookKeeperEditLogInputStream(lh, l, lastAddConfirmed);
long endTxId = HdfsConstants.InvalidTxid;
FSEditLogOp op = @in.ReadOp();
while (op != null)
{
if (endTxId == HdfsConstants.InvalidTxid || op.GetTransactionId() == endTxId + 1)
{
endTxId = op.GetTransactionId();
}
op = @in.ReadOp();
}
return(endTxId);
}
finally
{
if (@in != null)
{
@in.Close();
}
}
}
/// <exception cref="System.IO.IOException"/>
private IList <EditLogLedgerMetadata> GetLedgerList(long fromTxId, bool inProgressOk
)
{
IList <EditLogLedgerMetadata> ledgers = new AList <EditLogLedgerMetadata>();
try
{
IList <string> ledgerNames = zkc.GetChildren(ledgerPath, false);
foreach (string ledgerName in ledgerNames)
{
if (!inProgressOk && ledgerName.Contains(BkjmEditInprogress))
{
continue;
}
string legderMetadataPath = ledgerPath + "/" + ledgerName;
try
{
EditLogLedgerMetadata editLogLedgerMetadata = EditLogLedgerMetadata.Read(zkc, legderMetadataPath
);
if (editLogLedgerMetadata.GetLastTxId() != HdfsConstants.InvalidTxid && editLogLedgerMetadata
.GetLastTxId() < fromTxId)
{
// exclude already read closed edits, but include inprogress edits
// as this will be handled in caller
continue;
}
ledgers.AddItem(editLogLedgerMetadata);
}
catch (KeeperException.NoNodeException)
{
Log.Warn("ZNode: " + legderMetadataPath + " might have finalized and deleted." +
" So ignoring NoNodeException.");
}
}
}
catch (KeeperException e)
{
throw new IOException("Exception reading ledger list from zk", e);
}
catch (Exception ie)
{
Sharpen.Thread.CurrentThread().Interrupt();
throw new IOException("Interrupted getting list of ledgers from zk", ie);
}
ledgers.Sort(EditLogLedgerMetadata.Comparator);
return(ledgers);
}
public virtual void TestEmptyInputStream()
{
ZooKeeper zk = BKJMUtil.ConnectZooKeeper();
BookKeeper bkc = new BookKeeper(new ClientConfiguration(), zk);
try
{
LedgerHandle lh = bkc.CreateLedger(BookKeeper.DigestType.Crc32, Sharpen.Runtime.GetBytesForString
("foobar"));
lh.Close();
EditLogLedgerMetadata metadata = new EditLogLedgerMetadata("/foobar", HdfsConstants
.NamenodeLayoutVersion, lh.GetId(), unchecked ((int)(0x1234)));
try
{
new BookKeeperEditLogInputStream(lh, metadata, -1);
NUnit.Framework.Assert.Fail("Shouldn't get this far, should have thrown");
}
catch (IOException ioe)
{
NUnit.Framework.Assert.IsTrue(ioe.Message.Contains("Invalid first bk entry to read"
));
}
metadata = new EditLogLedgerMetadata("/foobar", HdfsConstants.NamenodeLayoutVersion
, lh.GetId(), unchecked ((int)(0x1234)));
try
{
new BookKeeperEditLogInputStream(lh, metadata, 0);
NUnit.Framework.Assert.Fail("Shouldn't get this far, should have thrown");
}
catch (IOException ioe)
{
NUnit.Framework.Assert.IsTrue(ioe.Message.Contains("Invalid first bk entry to read"
));
}
}
finally
{
bkc.Close();
zk.Close();
}
}
/// <summary>Construct BookKeeper edit log input stream.</summary>
/// <remarks>
/// Construct BookKeeper edit log input stream.
/// Starts reading from firstBookKeeperEntry. This allows the stream
/// to take a shortcut during recovery, as it doesn't have to read
/// every edit log transaction to find out what the last one is.
/// </remarks>
/// <exception cref="System.IO.IOException"/>
internal BookKeeperEditLogInputStream(LedgerHandle lh, EditLogLedgerMetadata metadata
, long firstBookKeeperEntry)
{
this.lh = lh;
this.firstTxId = metadata.GetFirstTxId();
this.lastTxId = metadata.GetLastTxId();
this.logVersion = metadata.GetDataLayoutVersion();
this.inProgress = metadata.IsInProgress();
if (firstBookKeeperEntry < 0 || firstBookKeeperEntry > lh.GetLastAddConfirmed())
{
throw new IOException("Invalid first bk entry to read: " + firstBookKeeperEntry +
", LAC: " + lh.GetLastAddConfirmed());
}
BufferedInputStream bin = new BufferedInputStream(new BookKeeperEditLogInputStream.LedgerInputStream
(lh, firstBookKeeperEntry));
tracker = new FSEditLogLoader.PositionTrackingInputStream(bin);
DataInputStream @in = new DataInputStream(tracker);
reader = new FSEditLogOp.Reader(@in, tracker, logVersion);
}
/// <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);
}
}
/// <summary>Construct BookKeeper edit log input stream.</summary>
/// <remarks>
/// Construct BookKeeper edit log input stream.
/// Starts reading from the first entry of the ledger.
/// </remarks>
/// <exception cref="System.IO.IOException"/>
internal BookKeeperEditLogInputStream(LedgerHandle lh, EditLogLedgerMetadata metadata
)
: this(lh, metadata, 0)
{
}
