bool GcscppRunner::DoWrite()

in e2e-examples/gcs/benchmark/gcscpp_runner.cc [218:267]

• 42 lines of code
• 7 McCabe index (conditional complexity)

bool GcscppRunner::DoWrite(int thread_id,
                           google::cloud::storage::Client storage_client) {
  const int64_t max_chunk_size = (parameters_.chunk_size < 0)
                                     ? parameters_.write_size
                                     : parameters_.chunk_size;
  absl::Cord content = GetRandomData(max_chunk_size);
  absl::string_view content_data = content.Flatten();

  if (parameters_.object_stop > 0) {
    std::cerr << "write doesn't support object_stop" << std::endl;
    return false;
  }
  if (parameters_.write_size <= 0) {
    std::cerr << "write_size should be greater than 0." << std::endl;
    return false;
  }

  for (int run = 0; run < parameters_.runs; run++) {
    std::string object = object_resolver_.Resolve(thread_id, run);
    absl::Time run_start = absl::Now();

    int64_t total_bytes = 0;
    std::vector<RunnerWatcher::Chunk> chunks;
    chunks.reserve(256);

    auto writer = storage_client.WriteObject(parameters_.bucket, object);
    if (!writer) {
      std::cerr << "Error writing object: " << writer.last_status() << "\n";
      return false;
    }

    for (int64_t o = 0; o < parameters_.write_size; o += max_chunk_size) {
      int64_t chunk_size = std::min(max_chunk_size, parameters_.write_size - o);
      writer.write(content_data.data(), chunk_size);

      RunnerWatcher::Chunk chunk = {absl::Now(), chunk_size};
      chunks.push_back(chunk);
      total_bytes += chunk_size;
    }
    writer.Close();
    absl::Time run_end = absl::Now();

    watcher_->NotifyCompleted(OperationType::Write, thread_id, 0,
                              ExtractPeer(writer.headers()), parameters_.bucket,
                              object, grpc::Status::OK, total_bytes, run_start,
                              run_end - run_start, std::move(chunks));
  }

  return true;
}