Function randomWrite

tests/meta/MetaTestBase.cc:208–254

}

CoTask<void> randomWrite(MetaOperator &meta,
                         storage::client::StorageClient &storage,
                         const Inode &inode,
                         uint64_t offset,
                         uint64_t length) {
  auto stripe = std::min((uint32_t)folly::divCeil(offset + length, (uint64_t)inode.asFile().layout.chunkSize),
                         inode.asFile().layout.stripeSize);
  if (inode.asFile().dynStripe && inode.asFile().dynStripe < stripe) {
    auto result = co_await meta.setAttr(SetAttrReq::extendStripe(flat::UserInfo{}, inode.id, stripe));
    CO_ASSERT_OK(result);
  }

  uint64_t chunkSize = inode.asFile().layout.chunkSize;
  std::vector<uint8_t> writeData(chunkSize, 0x00);
  std::vector<folly::SemiFuture<folly::Unit>> tasks;
  while (length) {
    auto offsetInChunk = offset % chunkSize;
    auto lengthInChunk = std::min(length, chunkSize - offsetInChunk);
    auto chunkId = inode.asFile().getChunkId(inode.id, offset);
    auto routingInfo = storage.getMgmtdClient().getRoutingInfo()->raw();
    XLOGF_IF(FATAL, !routingInfo, "No routingInfo");
    auto chainId = inode.asFile().getChainId(inode, offset, *routingInfo);
    XLOGF_IF(FATAL, !chainId, "resolve chainId failed: {}", chainId);

    auto task = [=, &storage, &writeData]() -> CoTask<void> {
      auto writeIO = storage.createWriteIO(storage::ChainId(*chainId),
                                           storage::ChunkId(chunkId->pack()),
                                           offsetInChunk,
                                           lengthInChunk,
                                           chunkSize,
                                           writeData.data(),
                                           nullptr);
      XLOGF(DBG, "write {} offset {}, offsetInChunk {} length {}", chunkId, offset, offsetInChunk, lengthInChunk);
      auto result = co_await storage.write(writeIO, flat::UserInfo());
      CO_ASSERT_FALSE(result.hasError()) << result.error().describe();
      CO_ASSERT_FALSE(writeIO.result.lengthInfo.hasError()) << writeIO.result.lengthInfo.error().describe();
      CO_ASSERT_EQ(*writeIO.result.lengthInfo, lengthInChunk);
    };

    tasks.push_back(folly::coro::co_invoke(task).scheduleOn(co_await folly::coro::co_current_executor).start());

    offset += lengthInChunk;
    length -= lengthInChunk;
  }

  co_await folly::collectAll(tasks.begin(), tasks.end());
}

CoTask<void> truncate(MetaOperator &meta,
                      storage::client::StorageClient &storage,