if (task_type == TTaskType::type::PUSH_STORAGE_POLICY ||

task_type == TTaskType::type::PUSH_COOLDOWN_CONF ||

task_type == TTaskType::type::COMPACTION) {

// no need to report task of these types

return true;

}

if (task_type == TTaskType::type::DROP && config::is_cloud_mode()) {

// cloud no need to report drop task status

return true;

}

if (signature == -1) { // No need to report task with unintialized signature

return true;

}

std::lock_guard lock(s_task_signatures_mtx);

auto& set = s_task_signatures[task_type];

return set.insert(signature).second;

size_t queue_size;

{

std::lock_guard lock(s_task_signatures_mtx);

auto& set = s_task_signatures[task_type];

set.erase(signature);

queue_size = set.size();

}

VLOG_NOTICE << "remove task info. type=" << task_type << ", signature=" << signature

<< ", queue_size=" << queue_size;

// Return result to FE

TMasterResult result;

uint32_t try_time = 0;

constexpr int TASK_FINISH_MAX_RETRY = 3;

while (try_time < TASK_FINISH_MAX_RETRY) {

DorisMetrics::instance()->finish_task_requests_total->increment(1);

Status client_status =

MasterServerClient::instance()->finish_task(finish_task_request, &result);

if (client_status.ok()) {

break;

} else {

DorisMetrics::instance()->finish_task_requests_failed->increment(1);

LOG_WARNING("failed to finish task")

.tag("type", finish_task_request.task_type)

.tag("signature", finish_task_request.signature)

.error(result.status);

try_time += 1;

}

sleep(1);

}

const TSchemaHash schema_hash, TTabletInfo* tablet_info) {

tablet_info->__set_tablet_id(tablet_id);

tablet_info->__set_schema_hash(schema_hash);

return engine.tablet_manager()->report_tablet_info(tablet_info);

const TTaskType::type task_type, TFinishTaskRequest* finish_task_request) {

Status status;

std::string_view process_name = "alter tablet";

// Check last schema change status, if failed delete tablet file

// Do not need to adjust delete success or not

// Because if delete failed create rollup will failed

TTabletId new_tablet_id = 0;

TSchemaHash new_schema_hash = 0;

if (status.ok()) {

new_tablet_id = agent_task_req.alter_tablet_req_v2.new_tablet_id;

new_schema_hash = agent_task_req.alter_tablet_req_v2.new_schema_hash;

auto mem_tracker = MemTrackerLimiter::create_shared(

MemTrackerLimiter::Type::SCHEMA_CHANGE,

fmt::format("EngineAlterTabletTask#baseTabletId={}:newTabletId={}",

std::to_string(agent_task_req.alter_tablet_req_v2.base_tablet_id),

std::to_string(agent_task_req.alter_tablet_req_v2.new_tablet_id),

engine.memory_limitation_bytes_per_thread_for_schema_change()));

SCOPED_ATTACH_TASK(mem_tracker);

DorisMetrics::instance()->create_rollup_requests_total->increment(1);

Status res = Status::OK();

try {

LOG_INFO("start {}", process_name)

.tag("signature", agent_task_req.signature)

.tag("base_tablet_id", agent_task_req.alter_tablet_req_v2.base_tablet_id)

.tag("new_tablet_id", new_tablet_id)

.tag("mem_limit",

engine.memory_limitation_bytes_per_thread_for_schema_change());

SchemaChangeJob job(engine, agent_task_req.alter_tablet_req_v2,

std::to_string(agent_task_req.alter_tablet_req_v2.__isset.job_id

? agent_task_req.alter_tablet_req_v2.job_id

: 0));

status = job.process_alter_tablet(agent_task_req.alter_tablet_req_v2);

} catch (const Exception& e) {

status = e.to_status();

}

if (!status.ok()) {

DorisMetrics::instance()->create_rollup_requests_failed->increment(1);

}

}

if (status.ok()) {

increase_report_version();

}

// Return result to fe

finish_task_request->__set_backend(BackendOptions::get_local_backend());

finish_task_request->__set_report_version(s_report_version);

finish_task_request->__set_task_type(task_type);

finish_task_request->__set_signature(signature);

std::vector<TTabletInfo> finish_tablet_infos;

if (status.ok()) {

TTabletInfo tablet_info;

status = get_tablet_info(engine, new_tablet_id, new_schema_hash, &tablet_info);

if (status.ok()) {

finish_tablet_infos.push_back(tablet_info);

}

}

if (!status.ok() && !status.is<NOT_IMPLEMENTED_ERROR>()) {

LOG_WARNING("failed to {}", process_name)

.tag("signature", agent_task_req.signature)

.tag("base_tablet_id", agent_task_req.alter_tablet_req_v2.base_tablet_id)

.tag("new_tablet_id", new_tablet_id)

.error(status);

} else {

finish_task_request->__set_finish_tablet_infos(finish_tablet_infos);

LOG_INFO("successfully {}", process_name)

.tag("signature", agent_task_req.signature)

.tag("base_tablet_id", agent_task_req.alter_tablet_req_v2.base_tablet_id)

.tag("new_tablet_id", new_tablet_id);

}

finish_task_request->__set_task_status(status.to_thrift());

int64_t signature, const TTaskType::type task_type,

TFinishTaskRequest* finish_task_request) {

Status status;

std::string_view process_name = "alter tablet";

// Check last schema change status, if failed delete tablet file

// Do not need to adjust delete success or not

// Because if delete failed create rollup will failed

TTabletId new_tablet_id = 0;

new_tablet_id = agent_task_req.alter_tablet_req_v2.new_tablet_id;

auto mem_tracker = MemTrackerLimiter::create_shared(

MemTrackerLimiter::Type::SCHEMA_CHANGE,

fmt::format("EngineAlterTabletTask#baseTabletId={}:newTabletId={}",

std::to_string(agent_task_req.alter_tablet_req_v2.base_tablet_id),

std::to_string(agent_task_req.alter_tablet_req_v2.new_tablet_id),

engine.memory_limitation_bytes_per_thread_for_schema_change()));

SCOPED_ATTACH_TASK(mem_tracker);

DorisMetrics::instance()->create_rollup_requests_total->increment(1);

LOG_INFO("start {}", process_name)

.tag("signature", agent_task_req.signature)

.tag("base_tablet_id", agent_task_req.alter_tablet_req_v2.base_tablet_id)

.tag("new_tablet_id", new_tablet_id)

.tag("mem_limit", engine.memory_limitation_bytes_per_thread_for_schema_change());

DCHECK(agent_task_req.alter_tablet_req_v2.__isset.job_id);

CloudSchemaChangeJob job(engine, std::to_string(agent_task_req.alter_tablet_req_v2.job_id),

agent_task_req.alter_tablet_req_v2.expiration);

status = [&]() {

HANDLE_EXCEPTION_IF_CATCH_EXCEPTION(

job.process_alter_tablet(agent_task_req.alter_tablet_req_v2),

[&](const doris::Exception& ex) {

DorisMetrics::instance()->create_rollup_requests_failed->increment(1);

job.clean_up_on_failed();

});

return Status::OK();

}();

if (status.ok()) {

increase_report_version();

LOG_INFO("successfully {}", process_name)

.tag("signature", agent_task_req.signature)

.tag("base_tablet_id", agent_task_req.alter_tablet_req_v2.base_tablet_id)

.tag("new_tablet_id", new_tablet_id);

} else {

LOG_WARNING("failed to {}", process_name)

.tag("signature", agent_task_req.signature)

.tag("base_tablet_id", agent_task_req.alter_tablet_req_v2.base_tablet_id)

.tag("new_tablet_id", new_tablet_id)

.error(status);

}

// Return result to fe

finish_task_request->__set_backend(BackendOptions::get_local_backend());

finish_task_request->__set_report_version(s_report_version);

finish_task_request->__set_task_type(task_type);

finish_task_request->__set_signature(signature);

finish_task_request->__set_task_status(status.to_thrift());

TabletSharedPtr& tablet, DataDir** dest_store) {

int64_t tablet_id = req.tablet_id;

tablet = engine.tablet_manager()->get_tablet(tablet_id);

if (tablet == nullptr) {

return Status::InternalError("could not find tablet {}", tablet_id);

}

if (req.__isset.data_dir) {

// request specify the data dir

*dest_store = engine.get_store(req.data_dir);

if (*dest_store == nullptr) {

return Status::InternalError("could not find data dir {}", req.data_dir);

}

} else {

// this is a storage medium

// get data dir by storage medium

// judge case when no need to migrate

uint32_t count = engine.available_storage_medium_type_count();

if (count <= 1) {

return Status::InternalError("available storage medium type count is less than 1");

}

// check current tablet storage medium

TStorageMedium::type storage_medium = req.storage_medium;

TStorageMedium::type src_storage_medium = tablet->data_dir()->storage_medium();

if (src_storage_medium == storage_medium) {

return Status::InternalError("tablet is already on specified storage medium {}",

storage_medium);

}

// get a random store of specified storage medium

auto stores = engine.get_stores_for_create_tablet(tablet->partition_id(), storage_medium);

if (stores.empty()) {

return Status::InternalError("failed to get root path for create tablet");

}

*dest_store = stores[0];

}

if (tablet->data_dir()->path() == (*dest_store)->path()) {

LOG_WARNING("tablet is already on specified path").tag("path", tablet->data_dir()->path());

return Status::Error<FILE_ALREADY_EXIST, false>("tablet is already on specified path: {}",

tablet->data_dir()->path());

}

// check local disk capacity

int64_t tablet_size = tablet->tablet_local_size();

if ((*dest_store)->reach_capacity_limit(tablet_size)) {

return Status::Error<EXCEEDED_LIMIT>("reach the capacity limit of path {}, tablet_size={}",

(*dest_store)->path(), tablet_size);

}

return Status::OK();

std::string_view name) {

TMasterResult result;

Status status = MasterServerClient::instance()->report(request, &result);

if (!status.ok()) [[unlikely]] {

LOG_WARNING("failed to report {}", name)

.tag("host", cluster_info->master_fe_addr.hostname)

.tag("port", cluster_info->master_fe_addr.port)

.error(status);

return false;

}

else if (result.status.status_code != TStatusCode::OK) [[unlikely]] {

LOG_WARNING("failed to report {}", name)

.tag("host", cluster_info->master_fe_addr.hostname)

.tag("port", cluster_info->master_fe_addr.port)

.error(result.status);

return false;

}

return true;

std::function<Status(const TAgentTaskRequest&)> submit_op) {

const TTaskType::type task_type = task.task_type;

int64_t signature = task.signature;

std::string type_str;

EnumToString(TTaskType, task_type, type_str);

VLOG_CRITICAL << "submitting task. type=" << type_str << ", signature=" << signature;

if (!register_task_info(task_type, signature)) {

LOG_WARNING("failed to register task").tag("type", type_str).tag("signature", signature);

// Duplicated task request, just return OK

return Status::OK();

}

// TODO(plat1ko): check task request member

// Set the receiving time of task so that we can determine whether it is timed out later

(const_cast<TAgentTaskRequest&>(task)).__set_recv_time(time(nullptr));

auto st = submit_op(task);

if (!st.ok()) [[unlikely]] {

LOG_INFO("failed to submit task").tag("type", type_str).tag("signature", signature);

return st;

}

LOG_INFO("successfully submit task").tag("type", type_str).tag("signature", signature);

return Status::OK();

// clang-format off

switch (task.task_type) {

#define ADD_TASK_COUNT(type) \

case TTaskType::type: \

type##_count << n; \

return;

ADD_TASK_COUNT(ALTER_INVERTED_INDEX)

ADD_TASK_COUNT(CHECK_CONSISTENCY)

ADD_TASK_COUNT(UPLOAD)

ADD_TASK_COUNT(DOWNLOAD)

ADD_TASK_COUNT(MAKE_SNAPSHOT)

ADD_TASK_COUNT(RELEASE_SNAPSHOT)

ADD_TASK_COUNT(MOVE)

ADD_TASK_COUNT(COMPACTION)

ADD_TASK_COUNT(PUSH_STORAGE_POLICY)

ADD_TASK_COUNT(PUSH_COOLDOWN_CONF)

ADD_TASK_COUNT(CREATE)

ADD_TASK_COUNT(DROP)

ADD_TASK_COUNT(PUBLISH_VERSION)

ADD_TASK_COUNT(CLEAR_TRANSACTION_TASK)

ADD_TASK_COUNT(UPDATE_TABLET_META_INFO)

ADD_TASK_COUNT(CLONE)

ADD_TASK_COUNT(STORAGE_MEDIUM_MIGRATE)

ADD_TASK_COUNT(GC_BINLOG)

ADD_TASK_COUNT(UPDATE_VISIBLE_VERSION)

ADD_TASK_COUNT(CALCULATE_DELETE_BITMAP)

#undef ADD_TASK_COUNT

case TTaskType::REALTIME_PUSH:

case TTaskType::PUSH:

if (task.push_req.push_type == TPushType::LOAD_V2) {

PUSH_count << n;

} else if (task.push_req.push_type == TPushType::DELETE) {

DELETE_count << n;

}

return;

case TTaskType::ALTER:

{

ALTER_count << n;

// cloud auto stop need sc jobs, a tablet's sc can also be considered a fragment

doris::g_fragment_executing_count << 1;

int64 now = duration_cast<std::chrono::milliseconds>(

std::chrono::system_clock::now().time_since_epoch())

.count();

g_fragment_last_active_time.set_value(now);

return;

}

default:

return;

}

// clang-format on

std::function<void(const TAgentTaskRequest& task)> callback)

: _callback(std::move(callback)) {

auto st = ThreadPoolBuilder(fmt::format("TaskWP_{}", name))

.set_min_threads(worker_count)

.set_max_threads(worker_count)

.build(&_thread_pool);

CHECK(st.ok()) << name << ": " << st;

if (_stopped.exchange(true)) {

return;

}

if (_thread_pool) {

_thread_pool->shutdown();

}

return _submit_task(task, [this](auto&& task) {

add_task_count(task, 1);

return _thread_pool->submit_func([this, task]() {

_callback(task);

add_task_count(task, -1);

});

});

const std::string& name, int normal_worker_count, int high_prior_worker_count,

std::function<void(const TAgentTaskRequest& task)> callback)

: _callback(std::move(callback)) {

for (int i = 0; i < normal_worker_count; ++i) {

auto st = Thread::create(

"Normal", name, [this] { normal_loop(); }, &_workers.emplace_back());

CHECK(st.ok()) << name << ": " << st;

}

for (int i = 0; i < high_prior_worker_count; ++i) {

auto st = Thread::create(

"HighPrior", name, [this] { high_prior_loop(); }, &_workers.emplace_back());

CHECK(st.ok()) << name << ": " << st;

}

{

std::lock_guard lock(_mtx);

if (_stopped) {

return;

}

_stopped = true;

}

_normal_condv.notify_all();

_high_prior_condv.notify_all();

for (auto&& w : _workers) {

if (w) {

w->join();

}

}

return _submit_task(task, [this](auto&& task) {

auto req = std::make_unique<TAgentTaskRequest>(task);

add_task_count(*req, 1);

if (req->__isset.priority && req->priority == TPriority::HIGH) {

std::lock_guard lock(_mtx);

_high_prior_queue.push_back(std::move(req));

_high_prior_condv.notify_one();

_normal_condv.notify_one();

} else {

std::lock_guard lock(_mtx);

_normal_queue.push_back(std::move(req));

_normal_condv.notify_one();

}

return Status::OK();

});

while (true) {

std::unique_ptr<TAgentTaskRequest> req;

{

std::unique_lock lock(_mtx);

_normal_condv.wait(lock, [&] {

return !_normal_queue.empty() || !_high_prior_queue.empty() || _stopped;

});

if (_stopped) {

return;

}

if (!_high_prior_queue.empty()) {

req = std::move(_high_prior_queue.front());

_high_prior_queue.pop_front();

} else if (!_normal_queue.empty()) {

req = std::move(_normal_queue.front());

_normal_queue.pop_front();

} else {

continue;

}

}

_callback(*req);

add_task_count(*req, -1);

}

while (true) {

std::unique_ptr<TAgentTaskRequest> req;

{

std::unique_lock lock(_mtx);

_high_prior_condv.wait(lock, [&] { return !_high_prior_queue.empty() || _stopped; });

if (_stopped) {

return;

}

if (_high_prior_queue.empty()) {

continue;

}

req = std::move(_high_prior_queue.front());

_high_prior_queue.pop_front();

}

_callback(*req);

add_task_count(*req, -1);

}

std::function<void()> callback)

: _name(std::move(name)) {

auto report_loop = [this, cluster_info, report_interval_s, callback = std::move(callback)] {

auto& engine = ExecEnv::GetInstance()->storage_engine();

engine.register_report_listener(this);

while (true) {

{

std::unique_lock lock(_mtx);

_condv.wait_for(lock, std::chrono::seconds(report_interval_s),

[&] { return _stopped || _signal; });

if (_stopped) {

break;

}

if (_signal) {

// Consume received signal

_signal = false;

}

}

if (cluster_info->master_fe_addr.port == 0) {

// port == 0 means not received heartbeat yet

LOG(INFO) << "waiting to receive first heartbeat from frontend before doing report";

continue;

}

callback();

}

engine.deregister_report_listener(this);

};

auto st = Thread::create("ReportWorker", _name, report_loop, &_thread);

CHECK(st.ok()) << _name << ": " << st;

{

std::lock_guard lock(_mtx);

_signal = true;

}

_condv.notify_all();

{

std::lock_guard lock(_mtx);

if (_stopped) {

return;

}

_stopped = true;

}

_condv.notify_all();

if (_thread) {

_thread->join();

}

const auto& alter_inverted_index_rq = req.alter_inverted_index_req;

LOG(INFO) << "get alter inverted index task. signature=" << req.signature

<< ", tablet_id=" << alter_inverted_index_rq.tablet_id

<< ", job_id=" << alter_inverted_index_rq.job_id;

Status status = Status::OK();

auto tablet_ptr = engine.tablet_manager()->get_tablet(alter_inverted_index_rq.tablet_id);

if (tablet_ptr != nullptr) {

EngineIndexChangeTask engine_task(engine, alter_inverted_index_rq);

SCOPED_ATTACH_TASK(engine_task.mem_tracker());

status = engine_task.execute();

} else {

status = Status::NotFound("could not find tablet {}", alter_inverted_index_rq.tablet_id);

}

// Return result to fe

TFinishTaskRequest finish_task_request;

finish_task_request.__set_backend(BackendOptions::get_local_backend());

finish_task_request.__set_task_type(req.task_type);

finish_task_request.__set_signature(req.signature);

std::vector<TTabletInfo> finish_tablet_infos;

if (!status.ok()) {

LOG(WARNING) << "failed to alter inverted index task, signature=" << req.signature

<< ", tablet_id=" << alter_inverted_index_rq.tablet_id

<< ", job_id=" << alter_inverted_index_rq.job_id << ", error=" << status;

} else {

LOG(INFO) << "successfully alter inverted index task, signature=" << req.signature

<< ", tablet_id=" << alter_inverted_index_rq.tablet_id

<< ", job_id=" << alter_inverted_index_rq.job_id;

TTabletInfo tablet_info;

status = get_tablet_info(engine, alter_inverted_index_rq.tablet_id,

alter_inverted_index_rq.schema_hash, &tablet_info);

if (status.ok()) {

finish_tablet_infos.push_back(tablet_info);

}

finish_task_request.__set_finish_tablet_infos(finish_tablet_infos);

}

finish_task_request.__set_task_status(status.to_thrift());

finish_task(finish_task_request);

remove_task_info(req.task_type, req.signature);

LOG(INFO) << "get update tablet meta task. signature=" << req.signature;

Status status;

const auto& update_tablet_meta_req = req.update_tablet_meta_info_req;

for (const auto& tablet_meta_info : update_tablet_meta_req.tabletMetaInfos) {

auto tablet = engine.tablet_manager()->get_tablet(tablet_meta_info.tablet_id);

if (tablet == nullptr) {

status = Status::NotFound("tablet not found");

LOG(WARNING) << "could not find tablet when update tablet meta. tablet_id="

<< tablet_meta_info.tablet_id;

continue;

}

bool need_to_save = false;

if (tablet_meta_info.__isset.partition_id) {

// for fix partition_id = 0

LOG(WARNING) << "change be tablet id: " << tablet->tablet_meta()->tablet_id()

<< "partition id from : " << tablet->tablet_meta()->partition_id()

<< " to : " << tablet_meta_info.partition_id;

auto succ = engine.tablet_manager()->update_tablet_partition_id(

tablet_meta_info.partition_id, tablet->tablet_meta()->tablet_id());

if (!succ) {

std::string err_msg = fmt::format(

"change be tablet id : {} partition_id : {} failed",

tablet->tablet_meta()->tablet_id(), tablet_meta_info.partition_id);

LOG(WARNING) << err_msg;

status = Status::InvalidArgument(err_msg);

continue;

}

need_to_save = true;

}

if (tablet_meta_info.__isset.storage_policy_id) {

tablet->tablet_meta()->set_storage_policy_id(tablet_meta_info.storage_policy_id);

need_to_save = true;

}

if (tablet_meta_info.__isset.is_in_memory) {

tablet->tablet_meta()->mutable_tablet_schema()->set_is_in_memory(

tablet_meta_info.is_in_memory);

std::shared_lock rlock(tablet->get_header_lock());

for (auto& rowset_meta : tablet->tablet_meta()->all_mutable_rs_metas()) {

rowset_meta->tablet_schema()->set_is_in_memory(tablet_meta_info.is_in_memory);

}

tablet->tablet_schema_unlocked()->set_is_in_memory(tablet_meta_info.is_in_memory);

need_to_save = true;

}

if (tablet_meta_info.__isset.compaction_policy) {

if (tablet_meta_info.compaction_policy != CUMULATIVE_SIZE_BASED_POLICY &&

tablet_meta_info.compaction_policy != CUMULATIVE_TIME_SERIES_POLICY) {

status = Status::InvalidArgument(

"invalid compaction policy, only support for size_based or "

"time_series");

continue;

}

tablet->tablet_meta()->set_compaction_policy(tablet_meta_info.compaction_policy);

need_to_save = true;

}

if (tablet_meta_info.__isset.time_series_compaction_goal_size_mbytes) {

if (tablet->tablet_meta()->compaction_policy() != CUMULATIVE_TIME_SERIES_POLICY) {

status = Status::InvalidArgument(

"only time series compaction policy support time series config");

continue;

}

tablet->tablet_meta()->set_time_series_compaction_goal_size_mbytes(

tablet_meta_info.time_series_compaction_goal_size_mbytes);

need_to_save = true;

}

if (tablet_meta_info.__isset.time_series_compaction_file_count_threshold) {

if (tablet->tablet_meta()->compaction_policy() != CUMULATIVE_TIME_SERIES_POLICY) {

status = Status::InvalidArgument(

"only time series compaction policy support time series config");

continue;

}

tablet->tablet_meta()->set_time_series_compaction_file_count_threshold(

tablet_meta_info.time_series_compaction_file_count_threshold);

need_to_save = true;

}

if (tablet_meta_info.__isset.time_series_compaction_time_threshold_seconds) {

if (tablet->tablet_meta()->compaction_policy() != CUMULATIVE_TIME_SERIES_POLICY) {

status = Status::InvalidArgument(

"only time series compaction policy support time series config");

continue;

}

tablet->tablet_meta()->set_time_series_compaction_time_threshold_seconds(

tablet_meta_info.time_series_compaction_time_threshold_seconds);

need_to_save = true;

}

if (tablet_meta_info.__isset.time_series_compaction_empty_rowsets_threshold) {

if (tablet->tablet_meta()->compaction_policy() != CUMULATIVE_TIME_SERIES_POLICY) {

status = Status::InvalidArgument(

"only time series compaction policy support time series config");

continue;

}

tablet->tablet_meta()->set_time_series_compaction_empty_rowsets_threshold(

tablet_meta_info.time_series_compaction_empty_rowsets_threshold);

need_to_save = true;

}

if (tablet_meta_info.__isset.time_series_compaction_level_threshold) {

if (tablet->tablet_meta()->compaction_policy() != CUMULATIVE_TIME_SERIES_POLICY) {

status = Status::InvalidArgument(

"only time series compaction policy support time series config");

continue;

}

tablet->tablet_meta()->set_time_series_compaction_level_threshold(

tablet_meta_info.time_series_compaction_level_threshold);

need_to_save = true;

}

if (tablet_meta_info.__isset.replica_id) {

tablet->tablet_meta()->set_replica_id(tablet_meta_info.replica_id);

}

if (tablet_meta_info.__isset.binlog_config) {

// check binlog_config require fields: enable, ttl_seconds, max_bytes, max_history_nums

const auto& t_binlog_config = tablet_meta_info.binlog_config;

if (!t_binlog_config.__isset.enable || !t_binlog_config.__isset.ttl_seconds ||

!t_binlog_config.__isset.max_bytes || !t_binlog_config.__isset.max_history_nums) {

status = Status::InvalidArgument("invalid binlog config, some fields not set");

LOG(WARNING) << fmt::format(

"invalid binlog config, some fields not set, tablet_id={}, "

"t_binlog_config={}",

tablet_meta_info.tablet_id,

apache::thrift::ThriftDebugString(t_binlog_config));

continue;

}

BinlogConfig new_binlog_config;

new_binlog_config = tablet_meta_info.binlog_config;

LOG(INFO) << fmt::format(

"update tablet meta binlog config. tablet_id={}, old_binlog_config={}, "

"new_binlog_config={}",

tablet_meta_info.tablet_id, tablet->tablet_meta()->binlog_config().to_string(),

new_binlog_config.to_string());

tablet->set_binlog_config(new_binlog_config);

need_to_save = true;

}

if (tablet_meta_info.__isset.enable_single_replica_compaction) {

std::shared_lock rlock(tablet->get_header_lock());

tablet->tablet_meta()->mutable_tablet_schema()->set_enable_single_replica_compaction(

tablet_meta_info.enable_single_replica_compaction);

for (auto& rowset_meta : tablet->tablet_meta()->all_mutable_rs_metas()) {

rowset_meta->tablet_schema()->set_enable_single_replica_compaction(

tablet_meta_info.enable_single_replica_compaction);

}

tablet->tablet_schema_unlocked()->set_enable_single_replica_compaction(

tablet_meta_info.enable_single_replica_compaction);

need_to_save = true;

}

if (tablet_meta_info.__isset.disable_auto_compaction) {

std::shared_lock rlock(tablet->get_header_lock());

tablet->tablet_meta()->mutable_tablet_schema()->set_disable_auto_compaction(

tablet_meta_info.disable_auto_compaction);

for (auto& rowset_meta : tablet->tablet_meta()->all_mutable_rs_metas()) {

rowset_meta->tablet_schema()->set_disable_auto_compaction(

tablet_meta_info.disable_auto_compaction);

}

tablet->tablet_schema_unlocked()->set_disable_auto_compaction(

tablet_meta_info.disable_auto_compaction);

need_to_save = true;

}

if (tablet_meta_info.__isset.skip_write_index_on_load) {

std::shared_lock rlock(tablet->get_header_lock());

tablet->tablet_meta()->mutable_tablet_schema()->set_skip_write_index_on_load(

tablet_meta_info.skip_write_index_on_load);

for (auto& rowset_meta : tablet->tablet_meta()->all_mutable_rs_metas()) {

rowset_meta->tablet_schema()->set_skip_write_index_on_load(

tablet_meta_info.skip_write_index_on_load);

}

tablet->tablet_schema_unlocked()->set_skip_write_index_on_load(

tablet_meta_info.skip_write_index_on_load);

need_to_save = true;

}

if (need_to_save) {

std::shared_lock rlock(tablet->get_header_lock());

tablet->save_meta();

}

}

LOG(INFO) << "finish update tablet meta task. signature=" << req.signature;

if (req.signature != -1) {

TFinishTaskRequest finish_task_request;

finish_task_request.__set_task_status(status.to_thrift());

finish_task_request.__set_backend(BackendOptions::get_local_backend());

finish_task_request.__set_task_type(req.task_type);

finish_task_request.__set_signature(req.signature);

finish_task(finish_task_request);

remove_task_info(req.task_type, req.signature);

}

uint32_t checksum = 0;

const auto& check_consistency_req = req.check_consistency_req;

EngineChecksumTask engine_task(engine, check_consistency_req.tablet_id,

check_consistency_req.schema_hash, check_consistency_req.version,

&checksum);

SCOPED_ATTACH_TASK(engine_task.mem_tracker());

Status status = engine_task.execute();

if (!status.ok()) {

LOG_WARNING("failed to check consistency")

.tag("signature", req.signature)

.tag("tablet_id", check_consistency_req.tablet_id)

.error(status);

} else {

LOG_INFO("successfully check consistency")

.tag("signature", req.signature)

.tag("tablet_id", check_consistency_req.tablet_id)

.tag("checksum", checksum);

}

TFinishTaskRequest finish_task_request;

finish_task_request.__set_backend(BackendOptions::get_local_backend());

finish_task_request.__set_task_type(req.task_type);

finish_task_request.__set_signature(req.signature);

finish_task_request.__set_task_status(status.to_thrift());

finish_task_request.__set_tablet_checksum(static_cast<int64_t>(checksum));

finish_task_request.__set_request_version(check_consistency_req.version);

finish_task(finish_task_request);

remove_task_info(req.task_type, req.signature);

TReportRequest request;

if (config::report_random_wait) {

random_sleep(5);

}

request.__isset.tasks = true;

{

std::lock_guard lock(s_task_signatures_mtx);

auto& tasks = request.tasks;

for (auto&& [task_type, signatures] : s_task_signatures) {

auto& set = tasks[task_type];

for (auto&& signature : signatures) {