Method DoWrite

be/src/runtime/io/disk-io-mgr.cc:260–302

}

Status WriteRange::DoWrite() {
  Status ret_status = Status::OK();
  Status close_status = Status::OK();
  DiskQueue* queue = io_ctx_->parent_->disk_queues_[disk_id_];
  int64_t written_bytes = 0;
  FileWriter* file_writer = disk_file_->GetFileWriter();
  /// DoWrite is used for Spilling.
  /// For spilling to local, we will open and close the file handle for
  /// each write range, which is the WriteOne() function, since it could
  /// be a random write in each file.
  /// For spilling to remote, we will keep the file handle open, until the
  /// write range is the last one of the file to do the sequential write.
  if (disk_file_->disk_type() == DiskFileType::LOCAL) {
    return file_writer->WriteOne(this);
  }
  {
    ScopedHistogramTimer write_timer(queue->write_latency());
    shared_lock<shared_mutex> lock(disk_file_->physical_file_lock_);
    ret_status = file_writer->Open();
    if (!ret_status.ok()) return DoWriteEnd(queue, ret_status);
    ret_status = file_writer->Write(this, &written_bytes);
    disk_file_->UpdateReadBufferMetaDataIfNeeded(written_bytes - len_);
    int64_t actual_file_size = disk_file_->actual_file_size();
    // actual_file_size is only set once, otherwise it is 0 by default. If it is still
    // not set, it is impossible to be full.
    if (actual_file_size != 0) {
      DCHECK_LE(written_bytes, disk_file_->actual_file_size());
      is_full_ = written_bytes == actual_file_size;
    } else {
      // If the actual size hasn't been set, the written bytes must be less than the
      // default file size.
      DCHECK_LT(written_bytes, disk_file_->file_size());
    }
    if (is_full_) close_status = file_writer->Close();
    if (ret_status.ok() && !close_status.ok()) ret_status = close_status;
    if (ret_status.ok() && is_full_) {
      // If the file is full, the file handle should be closed,
      // so set the file to persisted status.
      disk_file_->SetStatus(io::DiskFileStatus::PERSISTED);
    }
  }
  return DoWriteEnd(queue, ret_status);
}

Status WriteRange::DoWriteEnd(DiskQueue* queue, const Status& ret_status) {
  if (ret_status.ok()) {