IPFS BlockService (#59)

Signed-off-by: Sergey Kaprovich <[email protected]>

Author: sergkaprovich

core/storage/ipfs/CMakeLists.txt

@@ -22,3 +22,10 @@ target_link_libraries(ipfs_datastore_leveldb
     cid
     leveldb
     )
+
+add_library(ipfs_blockservice
+    impl/blockservice_impl.cpp
+    )
+target_link_libraries(ipfs_blockservice
+    buffer
+    )

core/storage/ipfs/block.hpp

@@ -0,0 +1,38 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef FILECOIN_STORAGE_IPFS_BLOCK_HPP
+#define FILECOIN_STORAGE_IPFS_BLOCK_HPP
+
+#include "common/buffer.hpp"
+#include "common/cid.hpp"
+
+namespace fc::storage::ipfs {
+  /**
+   * @interface Piece of data, which is used with BlockService
+   */
+  struct Block {
+    using Content = common::Buffer; /**< Alias for content type */
+
+    /**
+     * @brief Default destructor
+     */
+    virtual ~Block() = default;
+
+    /**
+     * @brief Get content identifier
+     * @return Block CID
+     */
+    virtual const CID &getCID() const = 0;
+
+    /**
+     * @brief Get block content
+     * @return Block's raw data for store in the BlockService
+     */
+    virtual const Content &getContent() const = 0;
+  };
+}  // namespace fc::storage::ipfs
+
+#endif

core/storage/ipfs/blockservice.hpp

@@ -0,0 +1,70 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef FILECOIN_STORAGE_IPFS_BLOCKSERVICE_HPP
+#define FILECOIN_STORAGE_IPFS_BLOCKSERVICE_HPP
+
+#include "common/buffer.hpp"
+#include "common/outcome.hpp"
+#include "storage/ipfs/datastore.hpp"
+
+#include "storage/ipfs/block.hpp"
+
+namespace fc::storage::ipfs {
+  /**
+   * @interface Provides a seamless interface to both local and remote storage
+   * backends
+   */
+  class BlockService {
+   public:
+    /**
+     * @brief Default destructor
+     */
+    virtual ~BlockService() = default;
+
+    /**
+     * @brief Add new block to local storage
+     * @param block - entity to add
+     * @return operation result
+     */
+    virtual outcome::result<void> addBlock(const Block &block) = 0;
+
+    /**
+     * @brief Check for block existence in the local and remote storage
+     * @param cid - block id
+     * @return operation result
+     */
+    virtual outcome::result<bool> has(const CID &cid) const = 0;
+
+    /**
+     * @brief Get block's content from local or remote storage
+     * @param cid - block id
+     * @return operation result
+     */
+    virtual outcome::result<Block::Content> getBlockContent(
+        const CID &cid) const = 0;
+
+    /**
+     * @brief Remove block from local storage
+     * @param cid - block id
+     * @return operation result
+     */
+    virtual outcome::result<void> removeBlock(const CID &cid) = 0;
+  };
+
+  /**
+   * @enum Block service errors
+   */
+  enum class BlockServiceError : int {
+    CID_NOT_FOUND = 1,
+    ADD_BLOCK_FAILED,
+    GET_BLOCK_FAILED,
+    REMOVE_BLOCK_FAILED
+  };
+}  // namespace fc::storage::ipfs
+
+OUTCOME_HPP_DECLARE_ERROR(fc::storage::ipfs, BlockServiceError);
+
+#endif

core/storage/ipfs/impl/blockservice_impl.cpp

@@ -0,0 +1,66 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "storage/ipfs/impl/blockservice_impl.hpp"
+
+using fc::storage::ipfs::Block;
+
+namespace fc::storage::ipfs {
+  BlockServiceImpl::BlockServiceImpl(std::shared_ptr<IpfsDatastore> data_store)
+      : local_storage_{std::move(data_store)} {
+    BOOST_ASSERT_MSG(local_storage_ != nullptr,
+                     "BlockService: IpfsDatastore does not exist");
+  }
+
+  outcome::result<void> BlockServiceImpl::addBlock(const Block &block) {
+    auto result = local_storage_->set(block.getCID(), block.getContent());
+    if (result.has_error()) {
+      return BlockServiceError::ADD_BLOCK_FAILED;
+    }
+    return outcome::success();
+  }
+
+  outcome::result<bool> BlockServiceImpl::has(const CID &cid) const {
+    return local_storage_->contains(cid);
+  }
+
+  outcome::result<Block::Content> BlockServiceImpl::getBlockContent(
+      const CID &cid) const {
+    outcome::result<Block::Content> data = local_storage_->get(cid);
+    if (data.has_error()) {
+      if (data.error() == IpfsDatastoreError::NOT_FOUND) {
+        return BlockServiceError::CID_NOT_FOUND;
+      }
+      return BlockServiceError::GET_BLOCK_FAILED;
+    }
+    return data;
+  }
+
+  outcome::result<void> BlockServiceImpl::removeBlock(const CID &cid) {
+    auto result = local_storage_->remove(cid);
+    if (result.has_error()) {
+      if (result.error() == IpfsDatastoreError::NOT_FOUND) {
+        return BlockServiceError::CID_NOT_FOUND;
+      }
+      return BlockServiceError::REMOVE_BLOCK_FAILED;
+    }
+    return outcome::success();
+  }
+}  // namespace fc::storage::ipfs
+
+OUTCOME_CPP_DEFINE_CATEGORY(fc::storage::ipfs, BlockServiceError, e) {
+  using fc::storage::ipfs::BlockServiceError;
+  switch (e) {
+    case BlockServiceError::CID_NOT_FOUND:
+      return "BlockServiceError: block with given CID not found";
+    case BlockServiceError::ADD_BLOCK_FAILED:
+      return "BlockServiceError: failed to add block to datastore";
+    case BlockServiceError::GET_BLOCK_FAILED:
+      return "BlockServiceError: failed to get block from datastore";
+    case BlockServiceError::REMOVE_BLOCK_FAILED:
+      return "BlockServiceError: failed to remove block from datastore";
+  }
+  return "BlockServiceError: unknown error";
+}

core/storage/ipfs/impl/blockservice_impl.hpp

@@ -0,0 +1,36 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef FILECOIN_STORAGE_IPFS_BLOCKSERVICE_IMPL_HPP
+#define FILECOIN_STORAGE_IPFS_BLOCKSERVICE_IMPL_HPP
+
+#include <memory>
+
+#include "storage/ipfs/blockservice.hpp"
+
+namespace fc::storage::ipfs {
+  class BlockServiceImpl : public BlockService {
+   public:
+    /**
+     * @brief Construct block service
+     * @param data_store - IPFS storage implementation
+     */
+    explicit BlockServiceImpl(std::shared_ptr<IpfsDatastore> data_store);
+
+    outcome::result<void> addBlock(const Block &block) override;
+
+    outcome::result<bool> has(const CID &cid) const override;
+
+    outcome::result<Block::Content> getBlockContent(
+        const CID &cid) const override;
+
+    outcome::result<void> removeBlock(const CID &cid) override;
+
+   private:
+    std::shared_ptr<IpfsDatastore> local_storage_; /**< Local data storage */
+  };
+}  // namespace fc::storage::ipfs
+
+#endif

test/core/storage/ipfs/CMakeLists.txt

@@ -16,3 +16,11 @@ target_link_libraries(in_memory_ipfs_datastore_test
     p2p::p2p_random_generator
     ipfs_datastore_in_memory
     )
+
+addtest(ipfs_blockservice_test
+    blockservice_test.cpp
+    )
+target_link_libraries(ipfs_blockservice_test
+    ipfs_blockservice
+    ipfs_datastore_in_memory
+    )

test/core/storage/ipfs/blockservice_test.cpp

@@ -0,0 +1,121 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include "storage/ipfs/impl/blockservice_impl.hpp"
+
+#include <memory>
+
+#include <gtest/gtest.h>
+#include "storage/ipfs/impl/in_memory_datastore.hpp"
+#include "testutil/outcome.hpp"
+
+using fc::CID;
+using fc::common::Buffer;
+using fc::common::getCidOf;
+using fc::common::kEmptyCid;
+using fc::storage::ipfs::Block;
+using fc::storage::ipfs::BlockServiceImpl;
+using fc::storage::ipfs::BlockServiceError;
+using fc::storage::ipfs::InMemoryDatastore;
+
+/**
+ * @brief Implementation of Block interface for testing purposes
+ * This interface can be used by any data structure (like Node from
+ * MerkleDAG service) and there are no single universal implementation
+ */
+struct BlockTestImpl : Block {
+  Content content; /**< Raw data */
+  CID cid;         /**< Block identifier */
+
+  /**
+   * @brief Construct Block
+   * @param data - raw content
+   */
+  BlockTestImpl(std::vector<uint8_t> data)
+      : content{data}, cid{getCidOf(content).value()} {}
+
+  /**
+   * @brief Get content identifier
+   * @return Block's CID
+   */
+  const CID &getCID() const override {
+    return this->cid;
+  }
+
+  /**
+   * @brief Get block's content
+   * @details Type of the return value depends on Block's interface
+   * implementation: it can be raw bytes, or CBOR/Protobuf serialized value
+   * @return Block's data
+   */
+  const Buffer &getContent() const override {
+    return this->content;
+  }
+};
+
+/**
+ * @class Test fixture for BlockService
+ */
+class BlockServiceTest : public ::testing::Test {
+ public:
+  /**
+   * @brief Initialize BlockService
+   */
+  BlockServiceTest() : block_service_(std::make_shared<InMemoryDatastore>()) {}
+
+ protected:
+
+  BlockServiceImpl block_service_; /**< Testing target */
+
+  BlockTestImpl sample_block_{
+      {4, 8, 15, 16, 23, 42}}; /**< Sample block with pre-defined data */
+};
+
+/**
+ * @given Sample block with pre-defined data
+ * @when Adding, checking existence and retrieving block back from BlockStorage
+ * @then Add block @and check its existence @and retrieve block back from BlockStorage
+ */
+TEST_F(BlockServiceTest, StoreBlockSuccess) {
+  EXPECT_OUTCOME_TRUE_1(block_service_.addBlock(sample_block_))
+  EXPECT_OUTCOME_TRUE(contains, block_service_.has(sample_block_.getCID()))
+  ASSERT_TRUE(contains);
+  EXPECT_OUTCOME_TRUE(block_content, block_service_.getBlockContent(sample_block_.getCID()))
+  ASSERT_EQ(block_content, sample_block_.getContent());
+}
+
+/**
+ * @given CID of the block, which doesn't exist in the BlockService
+ * @when Trying to check block existence in the BlockService
+ * @then Operation must be completed successfully with result "not exists"
+ */
+TEST_F(BlockServiceTest, CheckExistenceSuccess) {
+  EXPECT_OUTCOME_TRUE(contains, block_service_.has(sample_block_.getCID()))
+  ASSERT_FALSE(contains);
+}
+
+/**
+ * @given Sample block with pre-defined data
+ * @when Trying to remove an existence block
+ * @then Operation must be completed successfully
+ */
+TEST_F(BlockServiceTest, RemoveBlockSuccess) {
+  EXPECT_OUTCOME_TRUE_1(block_service_.addBlock(sample_block_))
+  EXPECT_OUTCOME_TRUE(block_status, block_service_.has(sample_block_.getCID()))
+  ASSERT_TRUE(block_status);
+  EXPECT_OUTCOME_TRUE_1(block_service_.removeBlock(sample_block_.getCID()))
+  EXPECT_OUTCOME_TRUE(removed_status, block_service_.has(sample_block_.getCID()))
+  ASSERT_FALSE(removed_status);
+}
+
+/**
+ * @given CID of the block, which doesn't exist in the BlockService
+ * @when Try to get nonexistent block from BlockService
+ * @then Attempt fails
+ */
+TEST_F(BlockServiceTest, GetInvalidCidFailure) {
+  BlockServiceError expected_error = BlockServiceError::CID_NOT_FOUND;
+  EXPECT_OUTCOME_FALSE(result, block_service_.getBlockContent(sample_block_.getCID()))
+  ASSERT_EQ(result.value(), static_cast<int>(expected_error));
+}