Method writeToChunks

tests/lib/UnitTestFabric.cc:703–791

}

bool UnitTestFabric::writeToChunks(storage::ChainId chainId,
                                   storage::ChunkId chunkBegin,
                                   storage::ChunkId chunkEnd,
                                   std::span<uint8_t> chunkData,
                                   uint32_t offset,
                                   uint32_t length,
                                   const storage::client::WriteOptions &options,
                                   std::vector<storage::IOResult> *results) {
  // register a block of memory

  if (length == 0) {
    length = chunkData.size();
  }

  auto regRes = storageClient_->registerIOBuffer(&chunkData[0], chunkData.size());

  if (!regRes) {
    return false;
  }

  auto ioBuffer = std::move(*regRes);

  // create write IOs

  std::vector<storage::client::WriteIO> writeIOs;
  storage::ChunkId chunkId = chunkBegin;

  for (uint32_t chunkIndex = 0; chunkId < chunkEnd; chunkId = storage::ChunkId(chunkBegin, ++chunkIndex)) {
    auto writeIO = storageClient_->createWriteIO(chainId,
                                                 chunkId,
                                                 offset /*offset*/,
                                                 length /*length*/,
                                                 setupConfig_.chunk_size() /*chunkSize*/,
                                                 &chunkData[0],
                                                 &ioBuffer);
    writeIOs.push_back(std::move(writeIO));
  }

  flat::UserInfo dummyUserInfo{};
  std::vector<folly::SemiFuture<folly::Expected<folly::Unit, hf3fs::Status>>> ioTasks;

  for (auto &writeIO : writeIOs) {
    auto task = storageClient_->write(writeIO, dummyUserInfo, options).scheduleOn(&requestExe_).start();
    ioTasks.push_back(std::move(task));
  }

  folly::coro::blockingWait(folly::coro::collectAllRange(std::move(ioTasks)));

  for (size_t writeIndex = 0; writeIndex < writeIOs.size(); writeIndex++) {
    const auto &writeIO = writeIOs[writeIndex];

    if (results) results->push_back(writeIO.result);

    if (!writeIO.result.lengthInfo) {
      XLOGF(ERR,
            "Write IO #{}/{} to chunk {} on {}: error code {}",
            writeIndex + 1,
            writeIOs.size(),