SERVER-68584 Generalize skipTicketAcquisitionForLock

18 files changed, 66 insertions, 63 deletions

diff --git a/src/mongo/db/commands/find_cmd.cpp b/src/mongo/db/commands/find_cmd.cpp
index dc704c411b6..147ce04d933 100644
--- a/src/mongo/db/commands/find_cmd.cpp
+++ b/src/mongo/db/commands/find_cmd.cpp
@@ -429,7 +429,7 @@ public:
                 // on ticket acquisition can cause complicated deadlocks. Primaries may depend on
                 // data reaching secondaries in order to proceed; and secondaries may get stalled
                 // replicating because of an inability to acquire a read ticket.
-                opCtx->lockState()->skipAcquireTicket();
+                opCtx->lockState()->setAdmissionPriority(AdmissionContext::Priority::kImmediate);
             }
 
             // If this read represents a reverse oplog scan, we want to bypass oplog visibility
diff --git a/src/mongo/db/commands/getmore_cmd.cpp b/src/mongo/db/commands/getmore_cmd.cpp
index ec99c214b1f..7ea168e4ade 100644
--- a/src/mongo/db/commands/getmore_cmd.cpp
+++ b/src/mongo/db/commands/getmore_cmd.cpp
@@ -722,7 +722,7 @@ public:
                 // on ticket acquisition can cause complicated deadlocks. Primaries may depend on
                 // data reaching secondaries in order to proceed; and secondaries may get stalled
                 // replicating because of an inability to acquire a read ticket.
-                opCtx->lockState()->skipAcquireTicket();
+                opCtx->lockState()->setAdmissionPriority(AdmissionContext::Priority::kImmediate);
             }
 
             // Perform validation checks which don't cause the cursor to be deleted on failure.
diff --git a/src/mongo/db/commands/server_status_command.cpp b/src/mongo/db/commands/server_status_command.cpp
index cd5ed9cad25..f1dbbcea879 100644
--- a/src/mongo/db/commands/server_status_command.cpp
+++ b/src/mongo/db/commands/server_status_command.cpp
@@ -88,7 +88,7 @@ public:
         // This command is important to observability, and like FTDC, does not need to acquire the
         // PBWM lock to return correct results.
         ShouldNotConflictWithSecondaryBatchApplicationBlock noPBWMBlock(opCtx->lockState());
-        opCtx->lockState()->skipAcquireTicket();
+        opCtx->lockState()->setAdmissionPriority(AdmissionContext::Priority::kImmediate);
 
         // --- basic fields that are global
 
diff --git a/src/mongo/db/concurrency/d_concurrency_test.cpp b/src/mongo/db/concurrency/d_concurrency_test.cpp
index 22c638c811f..8e11fa7ef62 100644
--- a/src/mongo/db/concurrency/d_concurrency_test.cpp
+++ b/src/mongo/db/concurrency/d_concurrency_test.cpp
@@ -1469,7 +1469,7 @@ TEST_F(DConcurrencyTestFixture, NoThrottlingWhenNotAcquiringTickets) {
     auto opctx2 = clientOpctxPairs[1].second.get();
 
     // Prevent the enforcement of ticket throttling.
-    opctx1->lockState()->skipAcquireTicket();
+    opctx1->lockState()->setAdmissionPriority(AdmissionContext::Priority::kImmediate);
 
     // Both locks should be acquired immediately because there is no throttling.
     Lock::GlobalRead R1(opctx1, Date_t::now(), Lock::InterruptBehavior::kThrow);
diff --git a/src/mongo/db/concurrency/lock_state.h b/src/mongo/db/concurrency/lock_state.h
index 392d0f7ef6d..8ff2b0bb5e0 100644
--- a/src/mongo/db/concurrency/lock_state.h
+++ b/src/mongo/db/concurrency/lock_state.h
@@ -420,32 +420,32 @@ public:
 };
 
 /**
- * RAII-style class to opt out of the ticket acquisition mechanism when acquiring a global lock.
- *
- * Operations that acquire the global lock but do not use any storage engine resources are eligible
- * to skip ticket acquisition. Otherwise, a ticket acquisition is required to prevent throughput
- * from suffering under high load.
+ * RAII-style class to set the priority for the ticket acquisition mechanism when acquiring a global
+ * lock.
  */
-class SkipTicketAcquisitionForLock {
+class SetTicketAquisitionPriorityForLock {
 public:
-    SkipTicketAcquisitionForLock(const SkipTicketAcquisitionForLock&) = delete;
-    SkipTicketAcquisitionForLock& operator=(const SkipTicketAcquisitionForLock&) = delete;
-    explicit SkipTicketAcquisitionForLock(OperationContext* opCtx)
-        : _opCtx(opCtx), _shouldAcquireTicket(_opCtx->lockState()->shouldAcquireTicket()) {
-        if (_shouldAcquireTicket) {
-            _opCtx->lockState()->skipAcquireTicket();
-        }
+    SetTicketAquisitionPriorityForLock(const SetTicketAquisitionPriorityForLock&) = delete;
+    SetTicketAquisitionPriorityForLock& operator=(const SetTicketAquisitionPriorityForLock&) =
+        delete;
+    explicit SetTicketAquisitionPriorityForLock(OperationContext* opCtx,
+                                                AdmissionContext::Priority priority)
+        : _opCtx(opCtx), _originalPriority(opCtx->lockState()->getAcquisitionPriority()) {
+        uassert(ErrorCodes::IllegalOperation,
+                "It is illegal for an operation to demote a high priority to a lower priority "
+                "operation",
+                _originalPriority != AdmissionContext::Priority::kImmediate ||
+                    priority == AdmissionContext::Priority::kImmediate);
+        _opCtx->lockState()->setAdmissionPriority(priority);
     }
 
-    ~SkipTicketAcquisitionForLock() {
-        if (_shouldAcquireTicket) {
-            _opCtx->lockState()->setAcquireTicket();
-        }
+    ~SetTicketAquisitionPriorityForLock() {
+        _opCtx->lockState()->setAdmissionPriority(_originalPriority);
     }
 
 private:
     OperationContext* _opCtx;
-    const bool _shouldAcquireTicket;
+    AdmissionContext::Priority _originalPriority;
 };
 
 /**
diff --git a/src/mongo/db/concurrency/lock_state_test.cpp b/src/mongo/db/concurrency/lock_state_test.cpp
index e5b03683058..d5750316327 100644
--- a/src/mongo/db/concurrency/lock_state_test.cpp
+++ b/src/mongo/db/concurrency/lock_state_test.cpp
@@ -1237,25 +1237,27 @@ TEST_F(LockerImplTest, ConvertLockPendingUnlockAndUnlock) {
     locker.unlockGlobal();
 }
 
-TEST_F(LockerImplTest, SkipTicketAcquisitionForLockRAIIType) {
+TEST_F(LockerImplTest, SetTicketAcquisitionForLockRAIIType) {
     auto opCtx = makeOperationContext();
 
     // By default, ticket acquisition is required.
     ASSERT_TRUE(opCtx->lockState()->shouldAcquireTicket());
 
     {
-        SkipTicketAcquisitionForLock skipTicketAcquisition(opCtx.get());
+        SetTicketAquisitionPriorityForLock setTicketAquisition(
+            opCtx.get(), AdmissionContext::Priority::kImmediate);
         ASSERT_FALSE(opCtx->lockState()->shouldAcquireTicket());
     }
 
     ASSERT_TRUE(opCtx->lockState()->shouldAcquireTicket());
 
     // If ticket acquisitions are disabled on the lock state, the RAII type has no effect.
-    opCtx->lockState()->skipAcquireTicket();
+    opCtx->lockState()->setAdmissionPriority(AdmissionContext::Priority::kImmediate);
     ASSERT_FALSE(opCtx->lockState()->shouldAcquireTicket());
 
     {
-        SkipTicketAcquisitionForLock skipTicketAcquisition(opCtx.get());
+        SetTicketAquisitionPriorityForLock setTicketAquisition(
+            opCtx.get(), AdmissionContext::Priority::kImmediate);
         ASSERT_FALSE(opCtx->lockState()->shouldAcquireTicket());
     }
 
diff --git a/src/mongo/db/concurrency/locker.h b/src/mongo/db/concurrency/locker.h
index bd7a80fe19e..d29774e39a8 100644
--- a/src/mongo/db/concurrency/locker.h
+++ b/src/mongo/db/concurrency/locker.h
@@ -510,22 +510,19 @@ public:
     }
 
     /**
-     * This will opt in or out of the ticket mechanism. This should be used sparingly for special
-     * purpose threads, such as FTDC and committing or aborting prepared transactions.
+     * This will set the admission priority for the ticket mechanism.
      */
-    void skipAcquireTicket() {
-        // Should not hold or wait for the ticket.
+    void setAdmissionPriority(AdmissionContext::Priority priority) {
         invariant(isNoop() || getClientState() == Locker::ClientState::kInactive);
-        _admCtx.setPriority(AdmissionContext::AcquisitionPriority::kHigh);
+        _admCtx.setPriority(priority);
     }
-    void setAcquireTicket() {
-        // Should hold or wait for the ticket.
-        invariant(isNoop() || getClientState() == Locker::ClientState::kInactive);
-        _admCtx.setPriority(AdmissionContext::AcquisitionPriority::kNormal);
+
+    AdmissionContext::Priority getAcquisitionPriority() {
+        return _admCtx.getPriority();
     }
 
     bool shouldAcquireTicket() const {
-        return _admCtx.getPriority() != AdmissionContext::AcquisitionPriority::kHigh;
+        return _admCtx.getPriority() != AdmissionContext::Priority::kImmediate;
     }
 
     /**
diff --git a/src/mongo/db/ftdc/collector.cpp b/src/mongo/db/ftdc/collector.cpp
index b6c8e5a081e..8f8af095e7d 100644
--- a/src/mongo/db/ftdc/collector.cpp
+++ b/src/mongo/db/ftdc/collector.cpp
@@ -68,7 +68,7 @@ std::tuple<BSONObj, Date_t> FTDCCollectorCollection::collect(Client* client) {
     // batches that are taking a long time.
     auto opCtx = client->makeOperationContext();
     ShouldNotConflictWithSecondaryBatchApplicationBlock shouldNotConflictBlock(opCtx->lockState());
-    opCtx->lockState()->skipAcquireTicket();
+    opCtx->lockState()->setAdmissionPriority(AdmissionContext::Priority::kImmediate);
 
     for (auto& collector : _collectors) {
         // Skip collection if this collector has no data to return
diff --git a/src/mongo/db/repl/oplog_batcher.cpp b/src/mongo/db/repl/oplog_batcher.cpp
index d7d57678edc..d7d48d06bf2 100644
--- a/src/mongo/db/repl/oplog_batcher.cpp
+++ b/src/mongo/db/repl/oplog_batcher.cpp
@@ -300,7 +300,7 @@ void OplogBatcher::_run(StorageInterface* storageInterface) {
             // We do not want to serialize the OplogBatcher with oplog application, nor
             // do we want to take a WiredTiger read ticket.
             ShouldNotConflictWithSecondaryBatchApplicationBlock noConflict(opCtx->lockState());
-            opCtx->lockState()->skipAcquireTicket();
+            opCtx->lockState()->setAdmissionPriority(AdmissionContext::Priority::kImmediate);
 
             // During storage change operations, we may shut down storage under a global lock
             // and wait for any storage-using opCtxs to exit.  This results in a deadlock with
diff --git a/src/mongo/db/repl/repl_set_commands.cpp b/src/mongo/db/repl/repl_set_commands.cpp
index 97a1e2ac1cd..cd17527bbf2 100644
--- a/src/mongo/db/repl/repl_set_commands.cpp
+++ b/src/mongo/db/repl/repl_set_commands.cpp
@@ -140,7 +140,7 @@ public:
                 // application.
                 ShouldNotConflictWithSecondaryBatchApplicationBlock shouldNotConflictBlock(
                     opCtx->lockState());
-                opCtx->lockState()->skipAcquireTicket();
+                opCtx->lockState()->setAdmissionPriority(AdmissionContext::Priority::kImmediate);
                 // We need to hold the lock so that we don't run when storage is being shutdown.
                 Lock::GlobalLock lk(opCtx,
                                     MODE_IS,
diff --git a/src/mongo/db/repl/replication_consistency_markers_impl.cpp b/src/mongo/db/repl/replication_consistency_markers_impl.cpp
index 9f41df15ce4..21f95afe229 100644
--- a/src/mongo/db/repl/replication_consistency_markers_impl.cpp
+++ b/src/mongo/db/repl/replication_consistency_markers_impl.cpp
@@ -428,7 +428,8 @@ ReplicationConsistencyMarkersImpl::refreshOplogTruncateAfterPointIfPrimary(
     // for durability. SERVER-60682 is an example with more pending prepared transactions than
     // storage tickets; the transaction coordinator could not persist the decision and
     // had to unnecessarily wait for prepared transactions to expire to make forward progress.
-    SkipTicketAcquisitionForLock skipTicketAcquisition(opCtx);
+    SetTicketAquisitionPriorityForLock setTicketAquisition(opCtx,
+                                                           AdmissionContext::Priority::kImmediate);
 
     // The locks necessary to write to the oplog truncate after point's collection and read from the
     // oplog collection must be taken up front so that the mutex can also be taken around both
diff --git a/src/mongo/db/repl/replication_coordinator_impl.cpp b/src/mongo/db/repl/replication_coordinator_impl.cpp
index 281445fa7d9..a943637c2e5 100644
--- a/src/mongo/db/repl/replication_coordinator_impl.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl.cpp
@@ -3226,7 +3226,7 @@ Status ReplicationCoordinatorImpl::processReplSetGetStatus(
         // application.
         ShouldNotConflictWithSecondaryBatchApplicationBlock shouldNotConflictBlock(
             opCtx->lockState());
-        opCtx->lockState()->skipAcquireTicket();
+        opCtx->lockState()->setAdmissionPriority(AdmissionContext::Priority::kImmediate);
         // We need to hold the lock so that we don't run when storage is being shutdown.
         Lock::GlobalLock lk(opCtx,
                             MODE_IS,
diff --git a/src/mongo/db/repl/storage_interface_impl.cpp b/src/mongo/db/repl/storage_interface_impl.cpp
index 0ce8e4bf344..dad1cbc45df 100644
--- a/src/mongo/db/repl/storage_interface_impl.cpp
+++ b/src/mongo/db/repl/storage_interface_impl.cpp
@@ -1486,7 +1486,8 @@ void StorageInterfaceImpl::waitForAllEarlierOplogWritesToBeVisible(OperationCont
                                                                    bool primaryOnly) {
     // Waiting for oplog writes to be visible in the oplog does not use any storage engine resources
     // and must skip ticket acquisition to avoid deadlocks with updating oplog visibility.
-    SkipTicketAcquisitionForLock skipTicketAcquisition(opCtx);
+    SetTicketAquisitionPriorityForLock setTicketAquisition(opCtx,
+                                                           AdmissionContext::Priority::kImmediate);
 
     AutoGetOplog oplogRead(opCtx, OplogAccessMode::kRead);
     if (primaryOnly &&
@@ -1502,7 +1503,8 @@ void StorageInterfaceImpl::oplogDiskLocRegister(OperationContext* opCtx,
                                                 bool orderedCommit) {
     // Setting the oplog visibility does not use any storage engine resources and must skip ticket
     // acquisition to avoid deadlocks with updating oplog visibility.
-    SkipTicketAcquisitionForLock skipTicketAcquisition(opCtx);
+    SetTicketAquisitionPriorityForLock setTicketAquisition(opCtx,
+                                                           AdmissionContext::Priority::kImmediate);
 
     AutoGetOplog oplogRead(opCtx, OplogAccessMode::kRead);
     fassert(28557,
diff --git a/src/mongo/db/s/transaction_coordinator_util.cpp b/src/mongo/db/s/transaction_coordinator_util.cpp
index c591bf839da..2d1b1d7c0d4 100644
--- a/src/mongo/db/s/transaction_coordinator_util.cpp
+++ b/src/mongo/db/s/transaction_coordinator_util.cpp
@@ -448,7 +448,8 @@ Future<repl::OpTime> persistDecision(txn::AsyncWorkScheduler& scheduler,
                     // Do not acquire a storage ticket in order to avoid unnecessary serialization
                     // with other prepared transactions that are holding a storage ticket
                     // themselves; see SERVER-60682.
-                    SkipTicketAcquisitionForLock skipTicketAcquisition(opCtx);
+                    SetTicketAquisitionPriorityForLock setTicketAquisition(
+                        opCtx, AdmissionContext::Priority::kImmediate);
                     getTransactionCoordinatorWorkerCurOpRepository()->set(
                         opCtx, lsid, txnNumberAndRetryCounter, CoordinatorAction::kWritingDecision);
                     return persistDecisionBlocking(
diff --git a/src/mongo/db/transaction/transaction_participant.cpp b/src/mongo/db/transaction/transaction_participant.cpp
index b47cd38f22a..a50a3c8624b 100644
--- a/src/mongo/db/transaction/transaction_participant.cpp
+++ b/src/mongo/db/transaction/transaction_participant.cpp
@@ -1402,7 +1402,7 @@ void TransactionParticipant::Participant::_releaseTransactionResourcesToOpCtx(
     }
 
     if (acquireTicket == AcquireTicket::kSkip) {
-        stashLocker->skipAcquireTicket();
+        stashLocker->setAdmissionPriority(AdmissionContext::Priority::kImmediate);
     }
 
     tempTxnResourceStash->release(opCtx);
diff --git a/src/mongo/util/concurrency/admission_context.h b/src/mongo/util/concurrency/admission_context.h
index e7643f47431..304a57dc434 100644
--- a/src/mongo/util/concurrency/admission_context.h
+++ b/src/mongo/util/concurrency/admission_context.h
@@ -54,18 +54,18 @@ public:
      *
      * 'kNormal': It's important that the operation be throttled under load. If this operation is
      * throttled, it will not affect system availability or observability. Most operations, both
-     * user and internal, should use this priority unless they qualify as 'kLow' or 'kHigh'
+     * user and internal, should use this priority unless they qualify as 'kLow' or 'kImmediate'
      * priority.
      *
-     * 'kHigh': It's crucial that the operation makes forward progress - bypassing ticket
+     * 'kImmediate': It's crucial that the operation makes forward progress - bypassing ticket
      * acquisition. Reserved for operations critical to availability (e.g. replication workers) or
      * observability (e.g. FTDC), and any operation that is releasing resources (e.g. committing or
      * aborting prepared transactions). Should be used sparingly.
      *
-     * TODO SERVER-67951: Update comment to address that kHigh priority operations are always
+     * TODO SERVER-67951: Update comment to address that kImmediate priority operations are always
      * granted a ticket immediately upon request.
      */
-    enum class AcquisitionPriority { kLow, kNormal, kHigh };
+    enum class Priority { kLow, kNormal, kImmediate };
 
     void start(TickSource* tickSource) {
         admissions++;
@@ -93,11 +93,11 @@ public:
         return _lockMode;
     }
 
-    void setPriority(AcquisitionPriority priority) {
+    void setPriority(Priority priority) {
         _priority = priority;
     }
 
-    AcquisitionPriority getPriority() const {
+    Priority getPriority() const {
         invariant(_priority);
         return _priority.get();
     }
@@ -107,7 +107,7 @@ private:
     int admissions{0};
     LockMode _lockMode = LockMode::MODE_NONE;
     // TODO SERVER-68933: Don't default _priority to kNormal.
-    boost::optional<AcquisitionPriority> _priority{AcquisitionPriority::kNormal};
+    boost::optional<Priority> _priority{Priority::kNormal};
 };
 
 }  // namespace mongo
diff --git a/src/mongo/util/concurrency/ticketholder.cpp b/src/mongo/util/concurrency/ticketholder.cpp
index 1598673fec1..27102eae388 100644
--- a/src/mongo/util/concurrency/ticketholder.cpp
+++ b/src/mongo/util/concurrency/ticketholder.cpp
@@ -829,9 +829,9 @@ SchedulingTicketHolder::Queue& PriorityTicketHolder::_getQueueToUse(
     OperationContext* opCtx, const AdmissionContext* admCtx) {
     auto priority = admCtx->getPriority();
     switch (priority) {
-        case AdmissionContext::AcquisitionPriority::kLow:
+        case AdmissionContext::Priority::kLow:
             return _queues[static_cast<unsigned int>(QueueType::LowPriorityQueue)];
-        case AdmissionContext::AcquisitionPriority::kNormal:
+        case AdmissionContext::Priority::kNormal:
             return _queues[static_cast<unsigned int>(QueueType::NormalPriorityQueue)];
         default:
             MONGO_UNREACHABLE;
diff --git a/src/mongo/util/concurrency/ticketholder_test.cpp b/src/mongo/util/concurrency/ticketholder_test.cpp
index 809c4ab991e..b25833dbea2 100644
--- a/src/mongo/util/concurrency/ticketholder_test.cpp
+++ b/src/mongo/util/concurrency/ticketholder_test.cpp
@@ -73,7 +73,7 @@ void basicTimeout(OperationContext* opCtx) {
     ASSERT_EQ(holder->outof(), 1);
 
     AdmissionContext admCtx;
-    admCtx.setPriority(AdmissionContext::AcquisitionPriority::kNormal);
+    admCtx.setPriority(AdmissionContext::Priority::kNormal);
     {
         auto ticket = holder->waitForTicket(opCtx, &admCtx, mode);
         ASSERT_EQ(holder->used(), 1);
@@ -183,7 +183,7 @@ void resizeTest(OperationContext* opCtx) {
     Stats stats(holder.get());
 
     AdmissionContext admCtx;
-    admCtx.setPriority(AdmissionContext::AcquisitionPriority::kNormal);
+    admCtx.setPriority(AdmissionContext::Priority::kNormal);
 
     auto ticket =
         holder->waitForTicketUntil(opCtx, &admCtx, Date_t::now() + Milliseconds{500}, mode);
@@ -368,7 +368,7 @@ TEST_F(TicketHolderTest, PriorityTwoQueuedOperations) {
         // Allocate the only available ticket. Priority is irrelevant when there are tickets
         // available.
         AdmissionContext admCtx;
-        admCtx.setPriority(AdmissionContext::AcquisitionPriority::kLow);
+        admCtx.setPriority(AdmissionContext::Priority::kLow);
         boost::optional<Ticket> ticket =
             holder.waitForTicket(_opCtx.get(), &admCtx, TicketHolder::WaitMode::kInterruptible);
         ASSERT(ticket);
@@ -380,7 +380,7 @@ TEST_F(TicketHolderTest, PriorityTwoQueuedOperations) {
         // Each ticket is assigned with a pointer to an AdmissionContext. The AdmissionContext must
         // survive the lifetime of the ticket.
         AdmissionContext admCtxLowPriority;
-        admCtxLowPriority.setPriority(AdmissionContext::AcquisitionPriority::kLow);
+        admCtxLowPriority.setPriority(AdmissionContext::Priority::kLow);
 
         stdx::thread lowPriorityThread([&]() {
             ticketLowPriority = holder.waitForTicket(opCtxLowPriority.get(),
@@ -395,7 +395,7 @@ TEST_F(TicketHolderTest, PriorityTwoQueuedOperations) {
         // Each ticket is assigned with a pointer to an AdmissionContext. The AdmissionContext must
         // survive the lifetime of the ticket.
         AdmissionContext admCtxNormalPriority;
-        admCtxNormalPriority.setPriority(AdmissionContext::AcquisitionPriority::kNormal);
+        admCtxNormalPriority.setPriority(AdmissionContext::Priority::kNormal);
 
         stdx::thread normalPriorityThread([&]() {
             ticketNormalPriority = holder.waitForTicket(opCtxNormalPriority.get(),
@@ -438,7 +438,7 @@ TEST_F(TicketHolderTest, PriorityTwoNormalOneLowQueuedOperations) {
         // Allocate the only available ticket. Priority is irrelevant when there are tickets
         // available.
         AdmissionContext admCtx;
-        admCtx.setPriority(AdmissionContext::AcquisitionPriority::kLow);
+        admCtx.setPriority(AdmissionContext::Priority::kLow);
         boost::optional<Ticket> ticket =
             holder.waitForTicket(_opCtx.get(), &admCtx, TicketHolder::WaitMode::kInterruptible);
         ASSERT(ticket);
@@ -450,7 +450,7 @@ TEST_F(TicketHolderTest, PriorityTwoNormalOneLowQueuedOperations) {
         // Each ticket is assigned with a pointer to an AdmissionContext. The AdmissionContext must
         // survive the lifetime of the ticket.
         AdmissionContext admCtxLowPriority;
-        admCtxLowPriority.setPriority(AdmissionContext::AcquisitionPriority::kLow);
+        admCtxLowPriority.setPriority(AdmissionContext::Priority::kLow);
 
         stdx::thread lowPriorityThread([&]() {
             ticketLowPriority = holder.waitForTicket(opCtxLowPriority.get(),
@@ -465,7 +465,7 @@ TEST_F(TicketHolderTest, PriorityTwoNormalOneLowQueuedOperations) {
         // Each ticket is assigned with a pointer to an AdmissionContext. The AdmissionContext must
         // survive the lifetime of the ticket.
         AdmissionContext admCtxNormal1Priority;
-        admCtxNormal1Priority.setPriority(AdmissionContext::AcquisitionPriority::kNormal);
+        admCtxNormal1Priority.setPriority(AdmissionContext::Priority::kNormal);
 
         stdx::thread normal1PriorityThread([&]() {
             ticketNormal1Priority = holder.waitForTicket(opCtxNormal1Priority.get(),
@@ -493,7 +493,7 @@ TEST_F(TicketHolderTest, PriorityTwoNormalOneLowQueuedOperations) {
         // Each ticket is assigned with a pointer to an AdmissionContext. The AdmissionContext must
         // survive the lifetime of the ticket.
         AdmissionContext admCtxNormal2Priority;
-        admCtxNormal2Priority.setPriority(AdmissionContext::AcquisitionPriority::kNormal);
+        admCtxNormal2Priority.setPriority(AdmissionContext::Priority::kNormal);
         stdx::thread normal2PriorityThread([&]() {
             ticketNormal2Priority = holder.waitForTicket(opCtxNormal2Priority.get(),
                                                          &admCtxNormal2Priority,