Merge pull request #4244 from vespa-engine/geirst/add-named-bucket-space-to-document-api-messages-in-c++

Geirst/add named bucket space to document api messages in c++

4 files changed, 174 insertions, 132 deletions

diff --git a/storage/src/tests/storageserver/documentapiconvertertest.cpp b/storage/src/tests/storageserver/documentapiconvertertest.cpp
index 7467bae0c41..386be60d88c 100644
--- a/storage/src/tests/storageserver/documentapiconvertertest.cpp
+++ b/storage/src/tests/storageserver/documentapiconvertertest.cpp
@@ -5,6 +5,7 @@
 #include <vespa/document/base/testdocrepo.h>
 #include <vespa/document/bucket/bucketidfactory.h>
 #include <vespa/document/datatype/documenttype.h>
+#include <vespa/document/select/parser.h>
 #include <vespa/document/test/make_document_bucket.h>
 #include <vespa/documentapi/documentapi.h>
 #include <vespa/messagebus/emptyreply.h>
@@ -14,6 +15,8 @@
 #include <vespa/storageapi/message/datagram.h>
 #include <vespa/storageapi/message/multioperation.h>
 #include <vespa/storageapi/message/persistence.h>
+#include <vespa/storageapi/message/removelocation.h>
+#include <vespa/storageapi/message/stat.h>
 #include <vespa/vespalib/testkit/test_kit.h>
 
 using document::Bucket;
@@ -29,8 +32,10 @@ using document::test::makeDocumentBucket;
 
 namespace storage {
 
-DocumentId defaultDocId("id:test:text/html::0");
-const Bucket defaultBucket(BucketSpace(5), BucketId(0));
+const DocumentId defaultDocId("id:test:text/html::0");
+const BucketSpace defaultBucketSpace(5);
+const vespalib::string defaultSpaceName("myspace");
+const Bucket defaultBucket(defaultBucketSpace, BucketId(0));
 
 struct MockBucketResolver : public BucketResolver {
     virtual Bucket bucketFromId(const DocumentId &documentId) const override {
@@ -39,6 +44,18 @@ struct MockBucketResolver : public BucketResolver {
         }
         return Bucket(BucketSpace(0), BucketId(0));
     }
+    virtual BucketSpace bucketSpaceFromName(const vespalib::string &bucketSpace) const override {
+        if (bucketSpace == defaultSpaceName) {
+            return defaultBucketSpace;
+        }
+        return BucketSpace(0);
+    }
+    virtual vespalib::string nameFromBucketSpace(const document::BucketSpace &bucketSpace) const override {
+        if (bucketSpace == defaultBucketSpace) {
+            return defaultSpaceName;
+        }
+        return "";
+    }
 };
 
 struct DocumentApiConverterTest : public CppUnit::TestFixture
@@ -50,7 +67,7 @@ struct DocumentApiConverterTest : public CppUnit::TestFixture
 
     DocumentApiConverterTest()
         : _bucketResolver(),
-          _repo(new DocumentTypeRepo(readDocumenttypesConfig(
+          _repo(std::make_shared<DocumentTypeRepo>(readDocumenttypesConfig(
                     TEST_PATH("config-doctypes.cfg")))),
           _html_type(*_repo->getDocumentType("text/html"))
     {
@@ -60,6 +77,33 @@ struct DocumentApiConverterTest : public CppUnit::TestFixture
         _converter.reset(new DocumentApiConverter("raw:", _bucketResolver));
     };
 
+    template <typename DerivedT, typename BaseT>
+    std::unique_ptr<DerivedT> dynamic_unique_ptr_cast(std::unique_ptr<BaseT> base) {
+        auto derived = dynamic_cast<DerivedT*>(base.get());
+        CPPUNIT_ASSERT(derived);
+        base.release();
+        return std::unique_ptr<DerivedT>(derived);
+    }
+
+    template <typename T>
+    std::unique_ptr<T> toStorageAPI(documentapi::DocumentMessage &msg) {
+        auto result = _converter->toStorageAPI(msg, _repo);
+        return dynamic_unique_ptr_cast<T>(std::move(result));
+    }
+
+    template <typename T>
+    std::unique_ptr<T> toStorageAPI(mbus::Reply &fromReply,
+                                    api::StorageCommand &fromCommand) {
+        auto result = _converter->toStorageAPI(static_cast<documentapi::DocumentReply&>(fromReply), fromCommand);
+        return dynamic_unique_ptr_cast<T>(std::move(result));
+    }
+
+    template <typename T>
+    std::unique_ptr<T> toDocumentAPI(api::StorageCommand &cmd) {
+        auto result = _converter->toDocumentAPI(cmd, _repo);
+        return dynamic_unique_ptr_cast<T>(std::move(result));
+    }
+
     void testPut();
     void testForwardedPut();
     void testUpdate();
@@ -73,6 +117,9 @@ struct DocumentApiConverterTest : public CppUnit::TestFixture
     void testVisitorInfo();
     void testMultiOperation();
     void testBatchDocumentUpdate();
+    void testStatBucket();
+    void testGetBucketList();
+    void testRemoveLocation();
 
     CPPUNIT_TEST_SUITE(DocumentApiConverterTest);
     CPPUNIT_TEST(testPut);
@@ -88,6 +135,9 @@ struct DocumentApiConverterTest : public CppUnit::TestFixture
     CPPUNIT_TEST(testVisitorInfo);
     CPPUNIT_TEST(testMultiOperation);
     CPPUNIT_TEST(testBatchDocumentUpdate);
+    CPPUNIT_TEST(testStatBucket);
+    CPPUNIT_TEST(testGetBucketList);
+    CPPUNIT_TEST(testRemoveLocation);
     CPPUNIT_TEST_SUITE_END();
 };
 
@@ -95,50 +145,38 @@ CPPUNIT_TEST_SUITE_REGISTRATION(DocumentApiConverterTest);
 
 void DocumentApiConverterTest::testPut()
 {
-    Document::SP doc(new Document(_html_type, defaultDocId));
+    auto doc = std::make_shared<Document>(_html_type, defaultDocId);
 
     documentapi::PutDocumentMessage putmsg(doc);
     putmsg.setTimestamp(1234);
 
-    std::unique_ptr<storage::api::StorageCommand> cmd = _converter->toStorageAPI(putmsg, _repo);
+    auto cmd = toStorageAPI<api::PutCommand>(putmsg);
     CPPUNIT_ASSERT_EQUAL(defaultBucket, cmd->getBucket());
-    api::PutCommand* pc = dynamic_cast<api::PutCommand*>(cmd.get());
-
-    CPPUNIT_ASSERT(pc);
-    CPPUNIT_ASSERT(pc->getDocument().get() == doc.get());
+    CPPUNIT_ASSERT(cmd->getDocument().get() == doc.get());
 
     std::unique_ptr<mbus::Reply> reply = putmsg.createReply();
     CPPUNIT_ASSERT(reply.get());
 
-    std::unique_ptr<storage::api::StorageReply> rep = _converter->toStorageAPI(
-            static_cast<documentapi::DocumentReply&>(*reply), *cmd);
-    api::PutReply* pr = dynamic_cast<api::PutReply*>(rep.get());
-    CPPUNIT_ASSERT(pr);
-
-    std::unique_ptr<mbus::Message> mbusmsg = _converter->toDocumentAPI(*pc, _repo);
+    toStorageAPI<api::PutReply>(*reply, *cmd);
 
-    documentapi::PutDocumentMessage* mbusput = dynamic_cast<documentapi::PutDocumentMessage*>(mbusmsg.get());
-    CPPUNIT_ASSERT(mbusput);
-    CPPUNIT_ASSERT(mbusput->getDocumentSP().get() == doc.get());
-    CPPUNIT_ASSERT(mbusput->getTimestamp() == 1234);
-};
+    auto mbusPut = toDocumentAPI<documentapi::PutDocumentMessage>(*cmd);
+    CPPUNIT_ASSERT(mbusPut->getDocumentSP().get() == doc.get());
+    CPPUNIT_ASSERT(mbusPut->getTimestamp() == 1234);
+}
 
 void DocumentApiConverterTest::testForwardedPut()
 {
-    Document::SP doc(new Document(_html_type, DocumentId(DocIdString("test", "test"))));
+    auto doc = std::make_shared<Document>(_html_type, DocumentId(DocIdString("test", "test")));
 
     documentapi::PutDocumentMessage* putmsg = new documentapi::PutDocumentMessage(doc);
     std::unique_ptr<mbus::Reply> reply(((documentapi::DocumentMessage*)putmsg)->createReply());
     reply->setMessage(std::unique_ptr<mbus::Message>(putmsg));
 
-    std::unique_ptr<storage::api::StorageCommand> cmd = _converter->toStorageAPI(*putmsg, _repo);
-    ((storage::api::PutCommand*)cmd.get())->setTimestamp(1234);
-
-    std::unique_ptr<storage::api::StorageReply> rep = cmd->makeReply();
-    api::PutReply* pr = dynamic_cast<api::PutReply*>(rep.get());
-    CPPUNIT_ASSERT(pr);
+    auto cmd = toStorageAPI<api::PutCommand>(*putmsg);
+    cmd->setTimestamp(1234);
 
-    _converter->transferReplyState(*pr, *reply);
+    auto rep = dynamic_unique_ptr_cast<api::PutReply>(cmd->makeReply());
+    _converter->transferReplyState(*rep, *reply);
 }
 
 void DocumentApiConverterTest::testUpdate()
@@ -148,24 +186,17 @@ void DocumentApiConverterTest::testUpdate()
     updateMsg.setOldTimestamp(1234);
     updateMsg.setNewTimestamp(5678);
 
-    auto storageCmd = _converter->toStorageAPI(updateMsg, _repo);
-    CPPUNIT_ASSERT_EQUAL(defaultBucket, storageCmd->getBucket());
-
-    auto updateCmd = dynamic_cast<api::UpdateCommand*>(storageCmd.get());
-    CPPUNIT_ASSERT(updateCmd);
+    auto updateCmd = toStorageAPI<api::UpdateCommand>(updateMsg);
+    CPPUNIT_ASSERT_EQUAL(defaultBucket, updateCmd->getBucket());
     CPPUNIT_ASSERT_EQUAL(update.get(), updateCmd->getUpdate().get());
     CPPUNIT_ASSERT_EQUAL(api::Timestamp(1234), updateCmd->getOldTimestamp());
     CPPUNIT_ASSERT_EQUAL(api::Timestamp(5678), updateCmd->getTimestamp());
 
     auto mbusReply = updateMsg.createReply();
     CPPUNIT_ASSERT(mbusReply.get());
-    auto storageReply = _converter->toStorageAPI(static_cast<documentapi::DocumentReply&>(*mbusReply), *storageCmd);
-    auto updateReply = dynamic_cast<api::UpdateReply*>(storageReply.get());
-    CPPUNIT_ASSERT(updateReply);
+    toStorageAPI<api::UpdateReply>(*mbusReply, *updateCmd);
 
-    auto mbusMsg = _converter->toDocumentAPI(*updateCmd, _repo);
-    auto mbusUpdate = dynamic_cast<documentapi::UpdateDocumentMessage*>(mbusMsg.get());
-    CPPUNIT_ASSERT(mbusUpdate);
+    auto mbusUpdate = toDocumentAPI<documentapi::UpdateDocumentMessage>(*updateCmd);
     CPPUNIT_ASSERT((&mbusUpdate->getDocumentUpdate()) == update.get());
     CPPUNIT_ASSERT_EQUAL(api::Timestamp(1234), mbusUpdate->getOldTimestamp());
     CPPUNIT_ASSERT_EQUAL(api::Timestamp(5678), mbusUpdate->getNewTimestamp());
@@ -174,81 +205,66 @@ void DocumentApiConverterTest::testUpdate()
 void DocumentApiConverterTest::testRemove()
 {
     documentapi::RemoveDocumentMessage removemsg(defaultDocId);
-    std::unique_ptr<storage::api::StorageCommand> cmd = _converter->toStorageAPI(removemsg, _repo);
+    auto cmd = toStorageAPI<api::RemoveCommand>(removemsg);
     CPPUNIT_ASSERT_EQUAL(defaultBucket, cmd->getBucket());
-
-    api::RemoveCommand* rc = dynamic_cast<api::RemoveCommand*>(cmd.get());
-
-    CPPUNIT_ASSERT(rc);
-    CPPUNIT_ASSERT_EQUAL(defaultDocId, rc->getDocumentId());
+    CPPUNIT_ASSERT_EQUAL(defaultDocId, cmd->getDocumentId());
 
     std::unique_ptr<mbus::Reply> reply = removemsg.createReply();
     CPPUNIT_ASSERT(reply.get());
 
-    std::unique_ptr<storage::api::StorageReply> rep = _converter->toStorageAPI(
-            static_cast<documentapi::DocumentReply&>(*reply), *cmd);
-    api::RemoveReply* pr = dynamic_cast<api::RemoveReply*>(rep.get());
-    CPPUNIT_ASSERT(pr);
-
-    std::unique_ptr<mbus::Message> mbusmsg = _converter->toDocumentAPI(*rc, _repo);
+    toStorageAPI<api::RemoveReply>(*reply, *cmd);
 
-    documentapi::RemoveDocumentMessage* mbusremove = dynamic_cast<documentapi::RemoveDocumentMessage*>(mbusmsg.get());
-    CPPUNIT_ASSERT(mbusremove);
-    CPPUNIT_ASSERT_EQUAL(defaultDocId, mbusremove->getDocumentId());
-};
+    auto mbusRemove = toDocumentAPI<documentapi::RemoveDocumentMessage>(*cmd);
+    CPPUNIT_ASSERT_EQUAL(defaultDocId, mbusRemove->getDocumentId());
+}
 
 void DocumentApiConverterTest::testGet()
 {
     documentapi::GetDocumentMessage getmsg(defaultDocId, "foo bar");
 
-    std::unique_ptr<storage::api::StorageCommand> cmd = _converter->toStorageAPI(getmsg, _repo);
+    auto cmd = toStorageAPI<api::GetCommand>(getmsg);
     CPPUNIT_ASSERT_EQUAL(defaultBucket, cmd->getBucket());
-
-    api::GetCommand* rc = dynamic_cast<api::GetCommand*>(cmd.get());
-
-    CPPUNIT_ASSERT(rc);
-    CPPUNIT_ASSERT_EQUAL(defaultDocId, rc->getDocumentId());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("foo bar"), rc->getFieldSet());
-};
+    CPPUNIT_ASSERT_EQUAL(defaultDocId, cmd->getDocumentId());
+    CPPUNIT_ASSERT_EQUAL(vespalib::string("foo bar"), cmd->getFieldSet());
+}
 
 void DocumentApiConverterTest::testCreateVisitor()
 {
     documentapi::CreateVisitorMessage cv("mylib", "myinstance", "control-dest", "data-dest");
-
+    cv.setBucketSpace(defaultSpaceName);
     cv.setTimeRemaining(123456);
-    std::unique_ptr<storage::api::StorageCommand> cmd = _converter->toStorageAPI(cv, _repo);
-    api::CreateVisitorCommand* pc = dynamic_cast<api::CreateVisitorCommand*>(cmd.get());
-
-    CPPUNIT_ASSERT(pc);
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("mylib"), pc->getLibraryName());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("myinstance"), pc->getInstanceId());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("control-dest"), pc->getControlDestination());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("data-dest"), pc->getDataDestination());
-    CPPUNIT_ASSERT_EQUAL(123456u, pc->getTimeout());
+
+    auto cmd = toStorageAPI<api::CreateVisitorCommand>(cv);
+    CPPUNIT_ASSERT_EQUAL(defaultBucketSpace, cmd->getBucket().getBucketSpace());
+    CPPUNIT_ASSERT_EQUAL(vespalib::string("mylib"), cmd->getLibraryName());
+    CPPUNIT_ASSERT_EQUAL(vespalib::string("myinstance"), cmd->getInstanceId());
+    CPPUNIT_ASSERT_EQUAL(vespalib::string("control-dest"), cmd->getControlDestination());
+    CPPUNIT_ASSERT_EQUAL(vespalib::string("data-dest"), cmd->getDataDestination());
+    CPPUNIT_ASSERT_EQUAL(123456u, cmd->getTimeout());
+
+    auto msg = toDocumentAPI<documentapi::CreateVisitorMessage>(*cmd);
+    CPPUNIT_ASSERT_EQUAL(defaultSpaceName, msg->getBucketSpace());
 }
 
 void DocumentApiConverterTest::testCreateVisitorHighTimeout()
 {
     documentapi::CreateVisitorMessage cv("mylib", "myinstance", "control-dest", "data-dest");
     cv.setTimeRemaining((uint64_t)std::numeric_limits<uint32_t>::max() + 1); // Will be INT_MAX
-    std::unique_ptr<storage::api::StorageCommand> cmd = _converter->toStorageAPI(cv, _repo);
-    api::CreateVisitorCommand* pc = dynamic_cast<api::CreateVisitorCommand*>(cmd.get());
-
-    CPPUNIT_ASSERT(pc);
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("mylib"), pc->getLibraryName());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("myinstance"), pc->getInstanceId());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("control-dest"), pc->getControlDestination());
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("data-dest"), pc->getDataDestination());
-    CPPUNIT_ASSERT_EQUAL((uint32_t) std::numeric_limits<int32_t>::max(), pc->getTimeout());
+
+    auto cmd = toStorageAPI<api::CreateVisitorCommand>(cv);
+    CPPUNIT_ASSERT_EQUAL(vespalib::string("mylib"), cmd->getLibraryName());
+    CPPUNIT_ASSERT_EQUAL(vespalib::string("myinstance"), cmd->getInstanceId());
+    CPPUNIT_ASSERT_EQUAL(vespalib::string("control-dest"), cmd->getControlDestination());
+    CPPUNIT_ASSERT_EQUAL(vespalib::string("data-dest"), cmd->getDataDestination());
+    CPPUNIT_ASSERT_EQUAL((uint32_t) std::numeric_limits<int32_t>::max(), cmd->getTimeout());
 }
 
 void DocumentApiConverterTest::testCreateVisitorReplyNotReady()
 {
     documentapi::CreateVisitorMessage cv("mylib", "myinstance", "control-dest", "data-dest");
-    std::unique_ptr<storage::api::StorageCommand> cmd = _converter->toStorageAPI(cv, _repo);
-    CPPUNIT_ASSERT(cmd.get());
-    api::CreateVisitorCommand& cvc = dynamic_cast<api::CreateVisitorCommand&>(*cmd);
-    api::CreateVisitorReply cvr(cvc);
+
+    auto cmd = toStorageAPI<api::CreateVisitorCommand>(cv);
+    api::CreateVisitorReply cvr(*cmd);
     cvr.setResult(api::ReturnCode(api::ReturnCode::NOT_READY, "not ready"));
 
     std::unique_ptr<documentapi::CreateVisitorReply> reply(
@@ -259,14 +275,12 @@ void DocumentApiConverterTest::testCreateVisitorReplyNotReady()
     CPPUNIT_ASSERT_EQUAL(document::BucketId(std::numeric_limits<int>::max()), reply->getLastBucket());
 }
 
-
 void DocumentApiConverterTest::testCreateVisitorReplyLastBucket()
 {
     documentapi::CreateVisitorMessage cv("mylib", "myinstance", "control-dest", "data-dest");
-    std::unique_ptr<storage::api::StorageCommand> cmd = _converter->toStorageAPI(cv, _repo);
-    CPPUNIT_ASSERT(cmd.get());
-    api::CreateVisitorCommand& cvc = dynamic_cast<api::CreateVisitorCommand&>(*cmd);
-    api::CreateVisitorReply cvr(cvc);
+
+    auto cmd = toStorageAPI<api::CreateVisitorCommand>(cv);
+    api::CreateVisitorReply cvr(*cmd);
     cvr.setLastBucket(document::BucketId(123));
     std::unique_ptr<documentapi::CreateVisitorReply> reply(
             dynamic_cast<documentapi::CreateVisitorReply*>(cv.createReply().release()));
@@ -276,17 +290,12 @@ void DocumentApiConverterTest::testCreateVisitorReplyLastBucket()
     CPPUNIT_ASSERT_EQUAL(document::BucketId(123), reply->getLastBucket());
 }
 
-
 void DocumentApiConverterTest::testDestroyVisitor()
 {
     documentapi::DestroyVisitorMessage cv("myinstance");
 
-    std::unique_ptr<storage::api::StorageCommand> cmd = _converter->toStorageAPI(cv, _repo);
-
-    api::DestroyVisitorCommand* pc = dynamic_cast<api::DestroyVisitorCommand*>(cmd.get());
-
-    CPPUNIT_ASSERT(pc);
-    CPPUNIT_ASSERT_EQUAL(vespalib::string("myinstance"), pc->getInstanceId());
+    auto cmd = toStorageAPI<api::DestroyVisitorCommand>(cv);
+    CPPUNIT_ASSERT_EQUAL(vespalib::string("myinstance"), cmd->getInstanceId());
 }
 
 void
@@ -300,10 +309,7 @@ DocumentApiConverterTest::testVisitorInfo()
 
     vicmd.setBucketsCompleted(bucketsCompleted);
 
-    std::unique_ptr<mbus::Message> mbusmsg = _converter->toDocumentAPI(vicmd, _repo);
-
-    documentapi::VisitorInfoMessage* mbusvi = dynamic_cast<documentapi::VisitorInfoMessage*>(mbusmsg.get());
-    CPPUNIT_ASSERT(mbusvi);
+    auto mbusvi = toDocumentAPI<documentapi::VisitorInfoMessage>(vicmd);
     CPPUNIT_ASSERT_EQUAL(document::BucketId(16, 1), mbusvi->getFinishedBuckets()[0]);
     CPPUNIT_ASSERT_EQUAL(document::BucketId(16, 2), mbusvi->getFinishedBuckets()[1]);
     CPPUNIT_ASSERT_EQUAL(document::BucketId(16, 4), mbusvi->getFinishedBuckets()[2]);
@@ -311,17 +317,13 @@ DocumentApiConverterTest::testVisitorInfo()
     std::unique_ptr<mbus::Reply> reply = mbusvi->createReply();
     CPPUNIT_ASSERT(reply.get());
 
-    std::unique_ptr<storage::api::StorageReply> rep = _converter->toStorageAPI(
-            static_cast<documentapi::DocumentReply&>(*reply), vicmd);
-    api::VisitorInfoReply* pr = dynamic_cast<api::VisitorInfoReply*>(rep.get());
-    CPPUNIT_ASSERT(pr);
+    toStorageAPI<api::VisitorInfoReply>(*reply, vicmd);
 }
 
 void
 DocumentApiConverterTest::testMultiOperation()
 {
-    //create a document
-    Document::SP doc(new Document(_html_type, DocumentId(DocIdString("test", "test"))));
+    auto doc = std::make_shared<Document>(_html_type, DocumentId(DocIdString("test", "test")));
 
     document::BucketIdFactory fac;
     document::BucketId bucketId = fac.getBucketId(doc->getId());
@@ -336,10 +338,7 @@ DocumentApiConverterTest::testMultiOperation()
         CPPUNIT_ASSERT(momsg.getBuffer().size() > 0);
 
         // Convert it to Storage API
-        std::unique_ptr<api::StorageCommand> stcmd = _converter->toStorageAPI(momsg, _repo);
-
-        api::MultiOperationCommand* mocmd = dynamic_cast<api::MultiOperationCommand*>(stcmd.get());
-        CPPUNIT_ASSERT(mocmd);
+        auto mocmd = toStorageAPI<api::MultiOperationCommand>(momsg);
         CPPUNIT_ASSERT(mocmd->getBuffer().size() > 0);
 
         // Get operations from Storage API message and check document
@@ -348,7 +347,7 @@ DocumentApiConverterTest::testMultiOperation()
         CPPUNIT_ASSERT_EQUAL(*doc, *dynamic_cast<document::Document*>(list.begin()->getDocument().get()));
 
         // Create Storage API Reply
-        std::unique_ptr<api::MultiOperationReply> moreply = std::unique_ptr<api::MultiOperationReply>(new api::MultiOperationReply(*mocmd));
+        auto moreply = std::make_unique<api::MultiOperationReply>(*mocmd);
         CPPUNIT_ASSERT(moreply.get());
 
         // convert storage api reply to mbus reply.....
@@ -360,9 +359,7 @@ DocumentApiConverterTest::testMultiOperation()
         mocmd.getOperations().addPut(*doc, 100);
 
         // Convert it to documentapi
-        std::unique_ptr<mbus::Message> mbmsg = _converter->toDocumentAPI(mocmd, _repo);
-        documentapi::MultiOperationMessage* momsg = dynamic_cast<documentapi::MultiOperationMessage*>(mbmsg.get());
-        CPPUNIT_ASSERT(momsg);
+        auto momsg = toDocumentAPI<documentapi::MultiOperationMessage>(mocmd);
 
         // Get operations from Document API msg and check document
         const vdslib::DocumentList& list = momsg->getOperations();
@@ -374,11 +371,7 @@ DocumentApiConverterTest::testMultiOperation()
         CPPUNIT_ASSERT(moreply.get());
 
         //Convert DocumentAPI reply to storageapi reply
-        std::unique_ptr<api::StorageReply> streply =
-            _converter->toStorageAPI(static_cast<documentapi::DocumentReply&>(*moreply), mocmd);
-        api::MultiOperationReply* mostreply = dynamic_cast<api::MultiOperationReply*>(streply.get());
-        CPPUNIT_ASSERT(mostreply);
-
+        toStorageAPI<api::MultiOperationReply>(*moreply, mocmd);
     }
 }
 
@@ -389,19 +382,19 @@ DocumentApiConverterTest::testBatchDocumentUpdate()
 
     {
         document::DocumentId docId(document::UserDocIdString("userdoc:test:1234:test1"));
-        document::DocumentUpdate::SP update(new document::DocumentUpdate(_html_type, docId));
+        auto update = std::make_shared<document::DocumentUpdate>(_html_type, docId);
         updates.push_back(update);
     }
 
     {
         document::DocumentId docId(document::UserDocIdString("userdoc:test:1234:test2"));
-        document::DocumentUpdate::SP update(new document::DocumentUpdate(_html_type, docId));
+        auto update = std::make_shared<document::DocumentUpdate>(_html_type, docId);
         updates.push_back(update);
     }
 
     {
         document::DocumentId docId(document::UserDocIdString("userdoc:test:1234:test3"));
-        document::DocumentUpdate::SP update(new document::DocumentUpdate(_html_type, docId));
+        auto update = std::make_shared<document::DocumentUpdate>(_html_type, docId);
         updates.push_back(update);
     }
 
@@ -410,9 +403,7 @@ DocumentApiConverterTest::testBatchDocumentUpdate()
         msg->addUpdate(updates[i]);
     }
 
-    std::unique_ptr<storage::api::StorageCommand> cmd = _converter->toStorageAPI(*msg, _repo);
-    api::BatchDocumentUpdateCommand* batchCmd = dynamic_cast<api::BatchDocumentUpdateCommand*>(cmd.get());
-    CPPUNIT_ASSERT(batchCmd);
+    auto batchCmd = toStorageAPI<api::BatchDocumentUpdateCommand>(*msg);
     CPPUNIT_ASSERT_EQUAL(updates.size(), batchCmd->getUpdates().size());
     for (std::size_t i = 0; i < updates.size(); ++i) {
         CPPUNIT_ASSERT_EQUAL(*updates[i], *batchCmd->getUpdates()[i]);
@@ -436,4 +427,40 @@ DocumentApiConverterTest::testBatchDocumentUpdate()
     CPPUNIT_ASSERT(mbusBatchReply->getDocumentsNotFound()[2] == true);
 }
 
+void
+DocumentApiConverterTest::testStatBucket()
+{
+    documentapi::StatBucketMessage msg(BucketId(123), "");
+    msg.setBucketSpace(defaultSpaceName);
+
+    auto cmd = toStorageAPI<api::StatBucketCommand>(msg);
+    CPPUNIT_ASSERT_EQUAL(Bucket(defaultBucketSpace, BucketId(123)), cmd->getBucket());
+
+    auto mbusMsg = toDocumentAPI<documentapi::StatBucketMessage>(*cmd);
+    CPPUNIT_ASSERT_EQUAL(BucketId(123), mbusMsg->getBucketId());
+    CPPUNIT_ASSERT_EQUAL(defaultSpaceName, mbusMsg->getBucketSpace());
+}
+
+void
+DocumentApiConverterTest::testGetBucketList()
+{
+    documentapi::GetBucketListMessage msg(BucketId(123));
+    msg.setBucketSpace(defaultSpaceName);
+
+    auto cmd = toStorageAPI<api::GetBucketListCommand>(msg);
+    CPPUNIT_ASSERT_EQUAL(Bucket(defaultBucketSpace, BucketId(123)), cmd->getBucket());
+}
+
+void
+DocumentApiConverterTest::testRemoveLocation()
+{
+    document::BucketIdFactory factory;
+    document::select::Parser parser(*_repo, factory);
+    documentapi::RemoveLocationMessage msg(factory, parser, "id.group == \"mygroup\"");
+    msg.setBucketSpace(defaultSpaceName);
+
+    auto cmd = toStorageAPI<api::RemoveLocationCommand>(msg);
+    CPPUNIT_ASSERT_EQUAL(defaultBucket, cmd->getBucket());
+}
+
 }
diff --git a/storage/src/vespa/storage/common/bucket_resolver.h b/storage/src/vespa/storage/common/bucket_resolver.h
index 7224a392e2f..f1e334807bf 100644
--- a/storage/src/vespa/storage/common/bucket_resolver.h
+++ b/storage/src/vespa/storage/common/bucket_resolver.h
@@ -2,6 +2,7 @@
 #pragma once
 
 #include <vespa/document/bucket/bucket.h>
+#include <vespa/vespalib/stllike/string.h>
 
 namespace document { class DocumentId; }
 
@@ -13,6 +14,8 @@ namespace storage {
 struct BucketResolver {
     virtual ~BucketResolver() {}
     virtual document::Bucket bucketFromId(const document::DocumentId &documentId) const = 0;
+    virtual document::BucketSpace bucketSpaceFromName(const vespalib::string &bucketSpace) const = 0;
+    virtual vespalib::string nameFromBucketSpace(const document::BucketSpace &bucketSpace) const = 0;
 };
 
 }
diff --git a/storage/src/vespa/storage/storageserver/communicationmanager.cpp b/storage/src/vespa/storage/storageserver/communicationmanager.cpp
index 71a918610e6..eae51b90165 100644
--- a/storage/src/vespa/storage/storageserver/communicationmanager.cpp
+++ b/storage/src/vespa/storage/storageserver/communicationmanager.cpp
@@ -275,6 +275,12 @@ struct PlaceHolderBucketResolver : public BucketResolver {
     virtual document::Bucket bucketFromId(const document::DocumentId &) const override {
         return document::Bucket(document::BucketSpace::placeHolder(), document::BucketId(0));
     }
+    virtual document::BucketSpace bucketSpaceFromName(const vespalib::string &) const override {
+        return document::BucketSpace::placeHolder();
+    }
+    virtual vespalib::string nameFromBucketSpace(const document::BucketSpace &) const override {
+        return "";
+    }
 };
 
 }
diff --git a/storage/src/vespa/storage/storageserver/documentapiconverter.cpp b/storage/src/vespa/storage/storageserver/documentapiconverter.cpp
index 331e32f43b8..c2761b3d832 100644
--- a/storage/src/vespa/storage/storageserver/documentapiconverter.cpp
+++ b/storage/src/vespa/storage/storageserver/documentapiconverter.cpp
@@ -76,7 +76,7 @@ DocumentApiConverter::toStorageAPI(documentapi::DocumentMessage& fromMsg,
     case DocumentProtocol::MESSAGE_CREATEVISITOR:
     {
         documentapi::CreateVisitorMessage& from(static_cast<documentapi::CreateVisitorMessage&>(fromMsg));
-        auto to = std::make_unique<api::CreateVisitorCommand>(BucketSpace::placeHolder(),
+        auto to = std::make_unique<api::CreateVisitorCommand>(_bucketResolver.bucketSpaceFromName(from.getBucketSpace()),
                                                               from.getLibraryName(), from.getInstanceId(),
                                                               from.getDocumentSelection());
 
@@ -118,13 +118,15 @@ DocumentApiConverter::toStorageAPI(documentapi::DocumentMessage& fromMsg,
     case DocumentProtocol::MESSAGE_STATBUCKET:
     {
         documentapi::StatBucketMessage& from(static_cast<documentapi::StatBucketMessage&>(fromMsg));
-        toMsg = std::make_unique<api::StatBucketCommand>(from.getBucket(), from.getDocumentSelection());
+        document::Bucket bucket(_bucketResolver.bucketSpaceFromName(from.getBucketSpace()), from.getBucketId());
+        toMsg = std::make_unique<api::StatBucketCommand>(bucket, from.getDocumentSelection());
         break;
     }
     case DocumentProtocol::MESSAGE_GETBUCKETLIST:
     {
         documentapi::GetBucketListMessage& from(static_cast<documentapi::GetBucketListMessage&>(fromMsg));
-        toMsg = std::make_unique<api::GetBucketListCommand>(from.getBucket());
+        document::Bucket bucket(_bucketResolver.bucketSpaceFromName(from.getBucketSpace()), from.getBucketId());
+        toMsg = std::make_unique<api::GetBucketListCommand>(bucket);
         break;
     }
     case DocumentProtocol::MESSAGE_VISITORINFO:
@@ -143,7 +145,8 @@ DocumentApiConverter::toStorageAPI(documentapi::DocumentMessage& fromMsg,
     case DocumentProtocol::MESSAGE_REMOVELOCATION:
     {
         documentapi::RemoveLocationMessage& from(static_cast<documentapi::RemoveLocationMessage&>(fromMsg));
-        api::RemoveLocationCommand::UP to(new api::RemoveLocationCommand(from.getDocumentSelection(), document::Bucket(BucketSpace::placeHolder(), document::BucketId(0))));
+        document::Bucket bucket(_bucketResolver.bucketSpaceFromName(from.getBucketSpace()), document::BucketId(0));
+        api::RemoveLocationCommand::UP to(new api::RemoveLocationCommand(from.getDocumentSelection(), bucket));
         toMsg.reset(to.release());
         break;
     }
@@ -295,6 +298,7 @@ DocumentApiConverter::toDocumentAPI(api::StorageCommand& fromMsg, const document
         documentapi::CreateVisitorMessage::UP to(
                 new documentapi::CreateVisitorMessage(from.getLibraryName(), from.getInstanceId(),
                                                       from.getControlDestination(), from.getDataDestination()));
+        to->setBucketSpace(_bucketResolver.nameFromBucketSpace(from.getBucketSpace()));
         to->setDocumentSelection(from.getDocumentSelection());
         to->setMaximumPendingReplyCount(from.getMaximumPendingReplyCount());
         to->setParameters(from.getParameters());
@@ -320,7 +324,9 @@ DocumentApiConverter::toDocumentAPI(api::StorageCommand& fromMsg, const document
     case api::MessageType::STATBUCKET_ID:
     {
         api::StatBucketCommand& from(static_cast<api::StatBucketCommand&>(fromMsg));
-        toMsg = std::make_unique<documentapi::StatBucketMessage>(from.getBucket(), from.getDocumentSelection());
+        auto statMsg = std::make_unique<documentapi::StatBucketMessage>(from.getBucket().getBucketId(), from.getDocumentSelection());
+        statMsg->setBucketSpace(_bucketResolver.nameFromBucketSpace(from.getBucket().getBucketSpace()));
+        toMsg = std::move(statMsg);
         break;
     }
     default: