Remove explicit ack and use feedtoken as a smartptr

4 files changed, 67 insertions, 96 deletions

diff --git a/searchcore/src/tests/proton/documentdb/combiningfeedview/combiningfeedview_test.cpp b/searchcore/src/tests/proton/documentdb/combiningfeedview/combiningfeedview_test.cpp
index d4af7b214b6..a997b3cc3db 100644
--- a/searchcore/src/tests/proton/documentdb/combiningfeedview/combiningfeedview_test.cpp
+++ b/searchcore/src/tests/proton/documentdb/combiningfeedview/combiningfeedview_test.cpp
@@ -72,22 +72,20 @@ struct MyFeedView : public test::DummyFeedView
         _metaStore.constructFreeList();
     }
 
-    // Implements IFeedView
-    virtual const DocumentMetaStore *getDocumentMetaStorePtr() const override { return &_metaStore; }
-    virtual void preparePut(PutOperation &) override { ++_preparePut; }
-    virtual void handlePut(FeedToken *, const PutOperation &) override { ++_handlePut; }
-    virtual void prepareUpdate(UpdateOperation &) override { ++_prepareUpdate; }
-    virtual void handleUpdate(FeedToken *, const UpdateOperation &) override { ++_handleUpdate; }
-    virtual void prepareRemove(RemoveOperation &) override { ++_prepareRemove; }
-    virtual void handleRemove(FeedToken *, const RemoveOperation &) override { ++_handleRemove; }
-    virtual void prepareDeleteBucket(DeleteBucketOperation &) override { ++_prepareDeleteBucket; }
-    virtual void handleDeleteBucket(const DeleteBucketOperation &) override
-    { ++_handleDeleteBucket; }
-    virtual void prepareMove(MoveOperation &) override { ++_prepareMove; }
-    virtual void handleMove(const MoveOperation &, IDestructorCallback::SP) override { ++_handleMove; }
-    virtual void heartBeat(SerialNum) override { ++_heartBeat; }
-    virtual void handlePruneRemovedDocuments(const PruneRemovedDocumentsOperation &) override { ++_handlePrune; }
-    virtual void handleCompactLidSpace(const CompactLidSpaceOperation &op) override {
+    const DocumentMetaStore *getDocumentMetaStorePtr() const override { return &_metaStore; }
+    void preparePut(PutOperation &) override { ++_preparePut; }
+    void handlePut(FeedToken, const PutOperation &) override { ++_handlePut; }
+    void prepareUpdate(UpdateOperation &) override { ++_prepareUpdate; }
+    void handleUpdate(FeedToken, const UpdateOperation &) override { ++_handleUpdate; }
+    void prepareRemove(RemoveOperation &) override { ++_prepareRemove; }
+    void handleRemove(FeedToken, const RemoveOperation &) override { ++_handleRemove; }
+    void prepareDeleteBucket(DeleteBucketOperation &) override { ++_prepareDeleteBucket; }
+    void handleDeleteBucket(const DeleteBucketOperation &) override { ++_handleDeleteBucket; }
+    void prepareMove(MoveOperation &) override { ++_prepareMove; }
+    void handleMove(const MoveOperation &, IDestructorCallback::SP) override { ++_handleMove; }
+    void heartBeat(SerialNum) override { ++_heartBeat; }
+    void handlePruneRemovedDocuments(const PruneRemovedDocumentsOperation &) override { ++_handlePrune; }
+    void handleCompactLidSpace(const CompactLidSpaceOperation &op) override {
         _wantedLidLimit = op.getLidLimit();
     }
 };
@@ -213,7 +211,7 @@ TEST_F("require that handlePut() sends to 1 feed view", Fixture)
 {
     PutOperation op = f.put(2);
     op.setDbDocumentId(DbDocumentId(READY, 2));
-    f._view.handlePut(NULL, op);
+    f._view.handlePut(FeedToken(), op);
     EXPECT_EQUAL(1u, f._ready._view->_handlePut);
     EXPECT_EQUAL(0u, f._removed._view->_handlePut);
     EXPECT_EQUAL(0u, f._notReady._view->_handlePut);
@@ -225,7 +223,7 @@ TEST_F("require that handlePut() sends to 2 feed views", Fixture)
     PutOperation op = f.put(2);
     op.setDbDocumentId(DbDocumentId(NOT_READY, 2));
     op.setPrevDbDocumentId(DbDocumentId(REMOVED, 2));
-    f._view.handlePut(NULL, op);
+    f._view.handlePut(FeedToken(), op);
     EXPECT_EQUAL(0u, f._ready._view->_handlePut);
     EXPECT_EQUAL(1u, f._removed._view->_handlePut);
     EXPECT_EQUAL(1u, f._notReady._view->_handlePut);
@@ -259,7 +257,7 @@ TEST_F("require that handleRemove() sends op with valid dbdId to 1 feed view", F
 {
     RemoveOperation op = f.remove(1);
     op.setDbDocumentId(DbDocumentId(REMOVED, 1));
-    f._view.handleRemove(NULL, op);
+    f._view.handleRemove(FeedToken(), op);
     EXPECT_EQUAL(0u, f._ready._view->_handleRemove);
     EXPECT_EQUAL(1u, f._removed._view->_handleRemove);
     EXPECT_EQUAL(0u, f._notReady._view->_handleRemove);
@@ -271,7 +269,7 @@ TEST_F("require that handleRemove() sends op with valid dbdId to 2 feed views",
     RemoveOperation op = f.remove(1);
     op.setDbDocumentId(DbDocumentId(REMOVED, 1));
     op.setPrevDbDocumentId(DbDocumentId(READY, 1));
-    f._view.handleRemove(NULL, op);
+    f._view.handleRemove(FeedToken(), op);
     EXPECT_EQUAL(1u, f._ready._view->_handleRemove);
     EXPECT_EQUAL(1u, f._removed._view->_handleRemove);
     EXPECT_EQUAL(0u, f._notReady._view->_handleRemove);
@@ -283,7 +281,7 @@ TEST_F("require that handleRemove() sends op with invalid dbdId to prev view", F
     RemoveOperation op = f.remove(1);
     // can be used in the case where removed feed view does not remember removes.
     op.setPrevDbDocumentId(DbDocumentId(READY, 1));
-    f._view.handleRemove(NULL, op);
+    f._view.handleRemove(FeedToken(), op);
     EXPECT_EQUAL(1u, f._ready._view->_handleRemove);
     EXPECT_EQUAL(0u, f._removed._view->_handleRemove);
     EXPECT_EQUAL(0u, f._notReady._view->_handleRemove);
@@ -317,7 +315,7 @@ TEST_F("require that handleUpdate() sends op to correct view", Fixture)
     UpdateOperation op = f.update(1);
     op.setDbDocumentId(DbDocumentId(READY, 1));
     op.setPrevDbDocumentId(DbDocumentId(READY, 1));
-    f._view.handleUpdate(NULL, op);
+    f._view.handleUpdate(FeedToken(), op);
     EXPECT_EQUAL(1u, f._ready._view->_handleUpdate);
     EXPECT_EQUAL(0u, f._removed._view->_handleUpdate);
     EXPECT_EQUAL(0u, f._notReady._view->_handleUpdate);
diff --git a/searchcore/src/tests/proton/documentdb/document_subdbs/document_subdbs_test.cpp b/searchcore/src/tests/proton/documentdb/document_subdbs/document_subdbs_test.cpp
index 547e400cd76..8369ec0630d 100644
--- a/searchcore/src/tests/proton/documentdb/document_subdbs/document_subdbs_test.cpp
+++ b/searchcore/src/tests/proton/documentdb/document_subdbs/document_subdbs_test.cpp
@@ -745,18 +745,15 @@ struct DocumentHandler
         op.setSerialNum(serialNum);
         return op;
     }
-    MoveOperation createMove(Document::UP doc, Timestamp timestamp,
-                             DbDocumentId sourceDbdId,
-                             uint32_t targetSubDbId,
-                             SerialNum serialNum)
+    MoveOperation createMove(Document::UP doc, Timestamp timestamp, DbDocumentId sourceDbdId,
+                             uint32_t targetSubDbId, SerialNum serialNum)
     {
         proton::test::Document testDoc(Document::SP(doc.release()), 0, timestamp);
         MoveOperation op(testDoc.getBucket(), testDoc.getTimestamp(), testDoc.getDoc(), sourceDbdId, targetSubDbId);
         op.setSerialNum(serialNum);
         return op;
     }
-    RemoveOperation createRemove(const DocumentId &docId, Timestamp timestamp,
-                                 SerialNum serialNum)
+    RemoveOperation createRemove(const DocumentId &docId, Timestamp timestamp, SerialNum serialNum)
     {
         const document::GlobalId &gid = docId.getGlobalId();
         BucketId bucket = gid.convertToBucketId();
@@ -769,7 +766,7 @@ struct DocumentHandler
     void putDoc(PutOperation &op) {
         IFeedView::SP feedView = _f._subDb.getFeedView();
         _f.runInMaster([&]() {    feedView->preparePut(op);
-                                  feedView->handlePut(NULL, op); } );
+                                  feedView->handlePut(FeedToken(), op); } );
     }
     void moveDoc(MoveOperation &op) {
         IFeedView::SP feedView = _f._subDb.getFeedView();
@@ -779,11 +776,10 @@ struct DocumentHandler
     {
         IFeedView::SP feedView = _f._subDb.getFeedView();
         _f.runInMaster([&]() {    feedView->prepareRemove(op);
-                                  feedView->handleRemove(NULL, op); } );
+                                  feedView->handleRemove(FeedToken(), op); } );
     }
     void putDocs() {
-        PutOperation putOp = createPut(std::move(createDoc(1, 22, 33)),
-                                       Timestamp(10), 10);
+        PutOperation putOp = createPut(std::move(createDoc(1, 22, 33)), Timestamp(10), 10);
         putDoc(putOp);
         putOp = createPut(std::move(createDoc(2, 44, 55)), Timestamp(20), 20);
         putDoc(putOp);
@@ -791,13 +787,8 @@ struct DocumentHandler
 };
 
 void
-assertAttribute(const AttributeGuard &attr,
-                const vespalib::string &name,
-                uint32_t numDocs,
-                int64_t doc1Value,
-                int64_t doc2Value,
-                SerialNum createSerialNum,
-                SerialNum lastSerialNum)
+assertAttribute(const AttributeGuard &attr, const vespalib::string &name, uint32_t numDocs,
+                int64_t doc1Value, int64_t doc2Value, SerialNum createSerialNum, SerialNum lastSerialNum)
 {
     EXPECT_EQUAL(name, attr->getName());
     EXPECT_EQUAL(numDocs, attr->getNumDocs());
@@ -808,17 +799,13 @@ assertAttribute(const AttributeGuard &attr,
 }
 
 void
-assertAttribute1(const AttributeGuard &attr,
-                           SerialNum createSerialNum,
-                           SerialNum lastSerialNum)
+assertAttribute1(const AttributeGuard &attr, SerialNum createSerialNum, SerialNum lastSerialNum)
 {
     assertAttribute(attr, "attr1", 3, 22, 44, createSerialNum, lastSerialNum);
 }
 
 void
-assertAttribute2(const AttributeGuard &attr,
-                           SerialNum createSerialNum,
-                           SerialNum lastSerialNum)
+assertAttribute2(const AttributeGuard &attr, SerialNum createSerialNum, SerialNum lastSerialNum)
 {
     assertAttribute(attr, "attr2", 3, 33, 55, createSerialNum, lastSerialNum);
 }
@@ -877,12 +864,10 @@ TEST_F("require that regular attributes are populated during reprocessing",
     requireThatAttributesArePopulatedDuringReprocessing<SearchableFixtureTwoField, ConfigDir2>(f);
 }
 
-namespace
-{
+namespace {
 
 bool
-assertOperation(DocumentOperation &op,
-                uint32_t expPrevSubDbId, uint32_t expPrevLid,
+assertOperation(DocumentOperation &op, uint32_t expPrevSubDbId, uint32_t expPrevLid,
                 uint32_t expSubDbId, uint32_t expLid)
 {
     if (!EXPECT_EQUAL(expPrevSubDbId, op.getPrevSubDbId())) {
diff --git a/searchcore/src/tests/proton/documentdb/feedhandler/feedhandler_test.cpp b/searchcore/src/tests/proton/documentdb/feedhandler/feedhandler_test.cpp
index b0b06a238c9..e70e83fd61e 100644
--- a/searchcore/src/tests/proton/documentdb/feedhandler/feedhandler_test.cpp
+++ b/searchcore/src/tests/proton/documentdb/feedhandler/feedhandler_test.cpp
@@ -140,12 +140,6 @@ struct MyReplayConfig : public IReplayConfig {
     virtual void replayConfig(SerialNum) override {}
 };
 
-void ackToken(FeedToken *token) {
-    if (token != NULL) {
-        token->ack();
-    }
-}
-
 struct MyDocumentMetaStore {
     struct Entry {
         DbDocumentId _id;
@@ -195,9 +189,9 @@ struct MyFeedView : public test::DummyFeedView {
     int update_count;
     SerialNum update_serial;
     MyFeedView(const DocumentTypeRepo::SP &dtr);
-    ~MyFeedView();
+    ~MyFeedView() override;
     void resetPutLatch(uint32_t count) { putLatch.reset(new vespalib::CountDownLatch(count)); }
-    virtual void preparePut(PutOperation &op) override {
+    void preparePut(PutOperation &op) override {
         prepareDocumentOperation(op, op.getDocument()->getId().getGlobalId());
     }
     void prepareDocumentOperation(DocumentOperation &op, const GlobalId &gid) {
@@ -208,7 +202,8 @@ struct MyFeedView : public test::DummyFeedView {
             op.setPrevTimestamp(entry->_prevTimestamp);
         }
     }
-    virtual void handlePut(FeedToken *token, const PutOperation &putOp) override {
+    void handlePut(FeedToken token, const PutOperation &putOp) override {
+        (void) token;
         LOG(info, "MyFeedView::handlePut(): docId(%s), putCount(%u), putLatchCount(%u)",
             putOp.getDocument()->getId().toString().c_str(), put_count,
             (putLatch.get() != NULL ? putLatch->getCount() : 0u));
@@ -221,23 +216,24 @@ struct MyFeedView : public test::DummyFeedView {
         if (putLatch.get() != NULL) {
             putLatch->countDown();
         }
-        ackToken(token);
     }
-    virtual void prepareUpdate(UpdateOperation &op) override {
+    void prepareUpdate(UpdateOperation &op) override {
         prepareDocumentOperation(op, op.getUpdate()->getId().getGlobalId());
     }
-    virtual void handleUpdate(FeedToken *token, const UpdateOperation &op) override {
+    void handleUpdate(FeedToken token, const UpdateOperation &op) override {
+        (void) token;
+
         ++update_count;
         update_serial = op.getSerialNum();
-        ackToken(token);
     }
-    virtual void handleRemove(FeedToken *token, const RemoveOperation &) override
-    { ++remove_count; ackToken(token); }
-    virtual void handleMove(const MoveOperation &, IDestructorCallback::SP) override { ++move_count; }
-    virtual void heartBeat(SerialNum) override { ++heartbeat_count; }
-    virtual void handlePruneRemovedDocuments(
-            const PruneRemovedDocumentsOperation &) override { ++prune_removed_count; }
-    virtual const ISimpleDocumentMetaStore *getDocumentMetaStorePtr() const override {
+    void handleRemove(FeedToken token, const RemoveOperation &) override {
+        (void) token;
+        ++remove_count;
+    }
+    void handleMove(const MoveOperation &, IDestructorCallback::SP) override { ++move_count; }
+    void heartBeat(SerialNum) override { ++heartbeat_count; }
+    void handlePruneRemovedDocuments(const PruneRemovedDocumentsOperation &) override { ++prune_removed_count; }
+    const ISimpleDocumentMetaStore *getDocumentMetaStorePtr() const override {
         return NULL;
     }
 };
@@ -317,8 +313,7 @@ MyTransport::~MyTransport() {}
 
 struct FeedTokenContext {
     MyTransport transport;
-    FeedToken::UP token_ap;
-    FeedToken &token;
+    FeedToken token;
 
     FeedTokenContext();
     ~FeedTokenContext();
@@ -333,10 +328,8 @@ struct FeedTokenContext {
 
 FeedTokenContext::FeedTokenContext()
     : transport(),
-      token_ap(new FeedToken(transport)),
-      token(*token_ap)
-{
-}
+      token(transport)
+{}
 
 FeedTokenContext::~FeedTokenContext() = default;
 
@@ -432,8 +425,7 @@ struct FeedHandlerFixture
         handler.init(1);
     }
 
-    ~FeedHandlerFixture()
-    {
+    ~FeedHandlerFixture() {
         writeService.sync();
     }
     template <class FunctionType>
@@ -484,7 +476,7 @@ TEST_F("require that outdated remove is ignored", FeedHandlerFixture)
     static_cast<DocumentOperation &>(*op).setPrevDbDocumentId(DbDocumentId(4));
     static_cast<DocumentOperation &>(*op).setPrevTimestamp(Timestamp(10000));
     FeedTokenContext token_context;
-    f.handler.performOperation(std::move(token_context.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token_context.token), std::move(op));
     EXPECT_EQUAL(0, f.feedView.remove_count);
     EXPECT_EQUAL(0, f.tls_writer.store_count);
 }
@@ -496,7 +488,7 @@ TEST_F("require that outdated put is ignored", FeedHandlerFixture)
                                           Timestamp(10), doc_context.doc));
     static_cast<DocumentOperation &>(*op).setPrevTimestamp(Timestamp(10000));
     FeedTokenContext token_context;
-    f.handler.performOperation(std::move(token_context.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token_context.token), std::move(op));
     EXPECT_EQUAL(0, f.feedView.put_count);
     EXPECT_EQUAL(0, f.tls_writer.store_count);
 }
@@ -575,7 +567,7 @@ TEST_F("require that remove of unknown document with known data type stores remo
     DocumentContext doc_context("id:test:searchdocument::foo", *f.schema.builder);
     FeedOperation::UP op(new RemoveOperation(doc_context.bucketId, Timestamp(10), doc_context.doc->getId()));
     FeedTokenContext token_context;
-    f.handler.performOperation(std::move(token_context.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token_context.token), std::move(op));
     EXPECT_EQUAL(1, f.feedView.remove_count);
     EXPECT_EQUAL(1, f.tls_writer.store_count);
 }
@@ -585,7 +577,7 @@ TEST_F("require that partial update for non-existing document is tagged as such"
     UpdateContext upCtx("id:test:searchdocument::foo", *f.schema.builder);
     FeedOperation::UP op(new UpdateOperation(upCtx.bucketId, Timestamp(10), upCtx.update));
     FeedTokenContext token_context;
-    f.handler.performOperation(std::move(token_context.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token_context.token), std::move(op));
     const UpdateResult *result = static_cast<const UpdateResult *>(token_context.getResult());
 
     EXPECT_FALSE(token_context.transport.documentWasFound);
@@ -603,7 +595,7 @@ TEST_F("require that partial update for non-existing document is created if spec
     f.feedView.metaStore.insert(upCtx.update->getId().getGlobalId(), MyDocumentMetaStore::Entry(5, 5, Timestamp(10)));
     FeedOperation::UP op(new UpdateOperation(upCtx.bucketId, Timestamp(10), upCtx.update));
     FeedTokenContext token_context;
-    f.handler.performOperation(std::move(token_context.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token_context.token), std::move(op));
     const UpdateResult *result = static_cast<const UpdateResult *>(token_context.getResult());
 
     EXPECT_TRUE(token_context.transport.documentWasFound);
@@ -624,7 +616,7 @@ TEST_F("require that put is rejected if resource limit is reached", FeedHandlerF
     DocumentContext docCtx("id:test:searchdocument::foo", *f.schema.builder);
     FeedOperation::UP op = std::make_unique<PutOperation>(docCtx.bucketId, Timestamp(10), docCtx.doc);
     FeedTokenContext token;
-    f.handler.performOperation(std::move(token.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token.token), std::move(op));
     EXPECT_EQUAL(0, f.feedView.put_count);
     EXPECT_EQUAL(Result::RESOURCE_EXHAUSTED, token.getResult()->getErrorCode());
     EXPECT_EQUAL("Put operation rejected for document 'id:test:searchdocument::foo' of type 'searchdocument': 'Attribute resource limit reached'",
@@ -639,7 +631,7 @@ TEST_F("require that update is rejected if resource limit is reached", FeedHandl
     UpdateContext updCtx("id:test:searchdocument::foo", *f.schema.builder);
     FeedOperation::UP op = std::make_unique<UpdateOperation>(updCtx.bucketId, Timestamp(10), updCtx.update);
     FeedTokenContext token;
-    f.handler.performOperation(std::move(token.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token.token), std::move(op));
     EXPECT_EQUAL(0, f.feedView.update_count);
     EXPECT_TRUE(dynamic_cast<const UpdateResult *>(token.getResult()));
     EXPECT_EQUAL(Result::RESOURCE_EXHAUSTED, token.getResult()->getErrorCode());
@@ -655,7 +647,7 @@ TEST_F("require that remove is NOT rejected if resource limit is reached", FeedH
     DocumentContext docCtx("id:test:searchdocument::foo", *f.schema.builder);
     FeedOperation::UP op = std::make_unique<RemoveOperation>(docCtx.bucketId, Timestamp(10), docCtx.doc->getId());
     FeedTokenContext token;
-    f.handler.performOperation(std::move(token.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token.token), std::move(op));
     EXPECT_EQUAL(1, f.feedView.remove_count);
     EXPECT_EQUAL(Result::NONE, token.getResult()->getErrorCode());
     EXPECT_EQUAL("", token.getResult()->getErrorMessage());
diff --git a/searchcore/src/tests/proton/documentdb/feedview/feedview_test.cpp b/searchcore/src/tests/proton/documentdb/feedview/feedview_test.cpp
index 4eefbed0a53..548ce8ba20d 100644
--- a/searchcore/src/tests/proton/documentdb/feedview/feedview_test.cpp
+++ b/searchcore/src/tests/proton/documentdb/feedview/feedview_test.cpp
@@ -571,7 +571,7 @@ struct FixtureBase
         return doc("doc:test:1", timestamp);
     }
 
-    void performPut(FeedToken *token, PutOperation &op) {
+    void performPut(FeedToken token, PutOperation &op) {
         getFeedView().preparePut(op);
         op.setSerialNum(++serial);
         getFeedView().handlePut(token, op);
@@ -586,10 +586,10 @@ struct FixtureBase
     void putAndWait(const DocumentContext &docCtx) {
         FeedTokenContext token(_tracer);
         PutOperation op(docCtx.bid, docCtx.ts, docCtx.doc);
-        runInMaster([&] () { performPut(&token.ft, op); });
+        runInMaster([&] () { performPut(token.ft, op); });
     }
 
-    void performUpdate(FeedToken *token, UpdateOperation &op) {
+    void performUpdate(FeedToken token, UpdateOperation &op) {
         getFeedView().prepareUpdate(op);
         op.setSerialNum(++serial);
         getFeedView().handleUpdate(token, op);
@@ -598,25 +598,21 @@ struct FixtureBase
     void updateAndWait(const DocumentContext &docCtx) {
         FeedTokenContext token(_tracer);
         UpdateOperation op(docCtx.bid, docCtx.ts, docCtx.upd);
-        runInMaster([&] () { performUpdate(&token.ft, op); });
+        runInMaster([&] () { performUpdate(token.ft, op); });
     }
 
-    void performRemove(FeedToken *token, RemoveOperation &op) {
+    void performRemove(FeedToken token, RemoveOperation &op) {
         getFeedView().prepareRemove(op);
         if (op.getValidNewOrPrevDbdId()) {
             op.setSerialNum(++serial);
-            getFeedView().handleRemove(token, op);
-        } else {
-            if (token != NULL) {
-                token->ack();
-            }
+            getFeedView().handleRemove(std::move(token), op);
         }
     }
 
     void removeAndWait(const DocumentContext &docCtx) {
         FeedTokenContext token(_tracer);
         RemoveOperation op(docCtx.bid, docCtx.ts, docCtx.doc->getId());
-        runInMaster([&] () { performRemove(&token.ft, op); });
+        runInMaster([&] () { performRemove(token.ft, op); });
     }
 
     void removeAndWait(const DocumentContext::List &docs) {