コード例 #1
0
        /// <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);
            }
        }
コード例 #2
0
        /// <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);
            }
        }