/// <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>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); } }