database/doris
2
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

[Bug] fix mem_tracker use-after-free & add UT for it (#3899)

Browse Source
This commit is contained in:
HuangWei
2020-06-20 19:08:53 +08:00
committed by GitHub
parent 8e895958d6
commit fdd65c50c4
7 changed files with 345 additions and 282 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
be/src/exec/tablet_sink.cpp
View File

@ -83,8 +83,8 @@ Status NodeChannel::init(RuntimeState* state) {
_rpc_timeout_ms = state->query_options().query_timeout * 1000;
_load_info = "load_id=" + print_id(_parent->_load_id) + ", txn_id" +
std::to_string(_parent->_txn_id);
_load_info = "load_id=" + print_id(_parent->_load_id) +
", txn_id=" + std::to_string(_parent->_txn_id);
_name = "NodeChannel[" + std::to_string(_index_id) + "-" + std::to_string(_node_id) + "]";
return Status::OK();
}
@ -141,7 +141,7 @@ Status NodeChannel::open_wait() {
_add_batch_closure = ReusableClosure<PTabletWriterAddBatchResult>::create();
_add_batch_closure->addFailedHandler([this]() {
_cancelled = true;
LOG(WARNING) << "NodeChannel add batch req rpc failed, " << print_load_info()
LOG(WARNING) << name() << " add batch req rpc failed, " << print_load_info()
<< ", node=" << node_info()->host << ":" << node_info()->brpc_port;
});
@ -160,7 +160,7 @@ Status NodeChannel::open_wait() {
}
} else {
_cancelled = true;
LOG(WARNING) << "NodeChannel add batch req success but status isn't ok, "
LOG(WARNING) << name() << " add batch req success but status isn't ok, "
<< print_load_info() << ", node=" << node_info()->host << ":"
<< node_info()->brpc_port << ", errmsg=" << status.get_error_msg();
}
@ -248,13 +248,12 @@ Status NodeChannel::close_wait(RuntimeState* state) {
timer.stop();
VLOG(1) << name() << " close_wait cost: " << timer.elapsed_time() / 1000000 << " ms";
{
std::lock_guard<std::mutex> lg(_pending_batches_lock);
DCHECK(_pending_batches.empty());
DCHECK(_cur_batch == nullptr);
}
if (_add_batches_finished) {
{
std::lock_guard<std::mutex> lg(_pending_batches_lock);
CHECK(_pending_batches.empty()) << name();
CHECK(_cur_batch == nullptr) << name();
}
state->tablet_commit_infos().insert(state->tablet_commit_infos().end(),
std::make_move_iterator(_tablet_commit_infos.begin()),
std::make_move_iterator(_tablet_commit_infos.end()));
@ -280,15 +279,6 @@ void NodeChannel::cancel() {
closure->cntl.set_timeout_ms(_rpc_timeout_ms);
_stub->tablet_writer_cancel(&closure->cntl, &request, &closure->result, closure);
request.release_id();
// Beware of the destruct sequence. RowBatches will use mem_trackers(include ancestors).
// Delete RowBatches here is a better choice to reduce the potential of dtor errors.
{
std::lock_guard<std::mutex> lg(_pending_batches_lock);
std::queue<AddBatchReq> empty;
std::swap(_pending_batches, empty);
_cur_batch.reset();
}
}
int NodeChannel::try_send_and_fetch_status() {
@ -358,6 +348,13 @@ Status NodeChannel::none_of(std::initializer_list<bool> vars) {
return st;
}
void NodeChannel::clear_all_batches() {
std::lock_guard<std::mutex> lg(_pending_batches_lock);
std::queue<AddBatchReq> empty;
std::swap(_pending_batches, empty);
_cur_batch.reset();
}
IndexChannel::~IndexChannel() {}
Status IndexChannel::init(RuntimeState* state, const std::vector<TTabletWithPartition>& tablets) {
@ -419,7 +416,15 @@ OlapTableSink::OlapTableSink(ObjectPool* pool, const RowDescriptor& row_desc,
}
}
OlapTableSink::~OlapTableSink() {}
OlapTableSink::~OlapTableSink() {
// We clear NodeChannels' batches here, cuz NodeChannels' batches destruction will use
// OlapTableSink::_mem_tracker and its parents.
// But their destructions are after OlapTableSink's.
// TODO: can be remove after all MemTrackers become shared.
for (auto index_channel : _channels) {
index_channel->for_each_node_channel([](NodeChannel* ch) { ch->clear_all_batches(); });
}
}
Status OlapTableSink::init(const TDataSink& t_sink) {
DCHECK(t_sink.__isset.olap_table_sink);
@ -575,7 +580,7 @@ Status OlapTableSink::open(RuntimeState* state) {
index_channel->for_each_node_channel([&index_channel](NodeChannel* ch) {
auto st = ch->open_wait();
if (!st.ok()) {
LOG(WARNING) << "tablet open failed, " << ch->print_load_info()
LOG(WARNING) << ch->name() << ": tablet open failed, " << ch->print_load_info()
<< ", node=" << ch->node_info()->host << ":"
<< ch->node_info()->brpc_port << ", errmsg=" << st.get_error_msg();
index_channel->mark_as_failed(ch);
@ -661,8 +666,7 @@ Status OlapTableSink::close(RuntimeState* state, Status close_status) {
{
SCOPED_TIMER(_close_timer);
for (auto index_channel : _channels) {
index_channel->for_each_node_channel(
[](NodeChannel* ch) { WARN_IF_ERROR(ch->mark_close(), ""); });
index_channel->for_each_node_channel([](NodeChannel* ch) { ch->mark_close(); });
}
for (auto index_channel : _channels) {
@ -672,7 +676,9 @@ Status OlapTableSink::close(RuntimeState* state, Status close_status) {
&actual_consume_ns](NodeChannel* ch) {
status = ch->close_wait(state);
if (!status.ok()) {
LOG(WARNING) << "close channel failed, " << ch->print_load_info();
LOG(WARNING)
<< ch->name() << ": close channel failed, " << ch->print_load_info()
<< ". error_msg=" << status.get_error_msg();
}
ch->time_report(&node_add_batch_counter_map, &serialize_batch_ns,
&mem_exceeded_block_ns, &queue_push_lock_ns,
@ -791,7 +797,8 @@ int OlapTableSink::_validate_data(RuntimeState* state, RowBatch* batch, Bitmap*
SlotDescriptor* desc = _output_tuple_desc->slots()[i];
if (desc->is_nullable() && tuple->is_null(desc->null_indicator_offset())) {
if (desc->type().type == TYPE_OBJECT) {
ss << "null is not allowed for bitmap column, column_name: " << desc->col_name();
ss << "null is not allowed for bitmap column, column_name: "
<< desc->col_name();
row_valid = false;
}
continue;

2
be/src/exec/tablet_sink.h
View File

@ -186,6 +186,8 @@ public:
Status none_of(std::initializer_list<bool> vars);
void clear_all_batches();
private:
OlapTableSink* _parent = nullptr;
int64_t _index_id = -1;

35
be/src/runtime/routine_load/routine_load_task_executor.h
View File

@ -41,12 +41,12 @@ class TRoutineLoadTask;
// to FE finally.
class RoutineLoadTaskExecutor {
public:
typedef std::function<void (StreamLoadContext*)> ExecFinishCallback;
typedef std::function<void(StreamLoadContext*)> ExecFinishCallback;
RoutineLoadTaskExecutor(ExecEnv* exec_env):
_exec_env(exec_env),
_thread_pool(config::routine_load_thread_pool_size, 1),
_data_consumer_pool(10) {
RoutineLoadTaskExecutor(ExecEnv* exec_env)
: _exec_env(exec_env),
_thread_pool(config::routine_load_thread_pool_size, 1),
_data_consumer_pool(10) {
REGISTER_GAUGE_DORIS_METRIC(routine_load_task_count, [this]() {
std::lock_guard<std::mutex> l(_lock);
return _task_map.size();
@ -58,21 +58,28 @@ public:
~RoutineLoadTaskExecutor() {
_thread_pool.shutdown();
_thread_pool.join();
LOG(INFO) << _task_map.size() << " not executed tasks left, cleanup";
for (auto it = _task_map.begin(); it != _task_map.end(); ++it) {
auto ctx = it->second;
if (ctx->unref()) {
delete ctx;
}
}
_task_map.clear();
}
// submit a routine load task
Status submit_task(const TRoutineLoadTask& task);
Status get_kafka_partition_meta(const PKafkaMetaProxyRequest& request, std::vector<int32_t>* partition_ids);
Status get_kafka_partition_meta(const PKafkaMetaProxyRequest& request,
std::vector<int32_t>* partition_ids);
private:
// execute the task
void exec_task(StreamLoadContext* ctx, DataConsumerPool* pool, ExecFinishCallback cb);
void err_handler(
StreamLoadContext* ctx,
const Status& st,
const std::string& err_msg);
void err_handler(StreamLoadContext* ctx, const Status& st, const std::string& err_msg);
// for test only
Status _execute_plan_for_test(StreamLoadContext* ctx);
@ -87,4 +94,4 @@ private:
std::unordered_map<UniqueId, StreamLoadContext*> _task_map;
};
} // end namespace
} // namespace doris

12
be/test/exec/tablet_sink_test.cpp
View File

@ -784,13 +784,15 @@ TEST_F(OlapTableSinkTest, add_batch_failed) {
_server->Start(4356, &options);
}
// ObjectPool create before RuntimeState, simulate actual situation better.
ObjectPool obj_pool;
TUniqueId fragment_id;
TQueryOptions query_options;
query_options.batch_size = 1;
RuntimeState state(fragment_id, query_options, TQueryGlobals(), _env);
state.init_mem_trackers(TUniqueId());
ObjectPool obj_pool;
TDescriptorTable tdesc_tbl;
auto t_data_sink = get_data_sink(&tdesc_tbl);
@ -859,9 +861,17 @@ TEST_F(OlapTableSinkTest, add_batch_failed) {
memcpy(str_val->ptr, "abc", str_val->len);
batch.commit_last_row();
}
// Channels will be cancelled internally, coz brpc returns k_add_batch_status.
k_add_batch_status = Status::InternalError("dummy failed");
st = sink.send(&state, &batch);
ASSERT_TRUE(st.ok());
// Send batch multiple times, can make _cur_batch or _pending_batches(in channels) not empty.
// To ensure the order of releasing resource is OK.
sink.send(&state, &batch);
sink.send(&state, &batch);
// close
st = sink.close(&state, Status::OK());
ASSERT_FALSE(st.ok());

328
be/test/exprs/string_functions_test.cpp
View File

@ -16,11 +16,11 @@
// under the License.
#include "exprs/string_functions.h"
#include "util/logging.h"
#include "testutil/function_utils.h"
#include "exprs/anyval_util.h"
#include <iostream>
#include <string>
#include "exprs/anyval_util.h"
#include "testutil/function_utils.h"
#include "util/logging.h"
#include <gtest/gtest.h>
@ -34,9 +34,7 @@ public:
utils = new FunctionUtils();
ctx = utils->get_fn_ctx();
}
void TearDown() {
delete utils;
}
void TearDown() { delete utils; }
private:
FunctionUtils* utils;
@ -69,7 +67,8 @@ TEST_F(StringFunctionsTest, money_format_large_int) {
__int128 value;
ss >> value;
StringVal result = StringFunctions::money_format(context, doris_udf::LargeIntVal(value));
StringVal expected = AnyValUtil::from_string_temp(context, std::string("170,141,183,460,469,231,731,687,303,715,884,105,727.00"));
StringVal expected = AnyValUtil::from_string_temp(
context, std::string("170,141,183,460,469,231,731,687,303,715,884,105,727.00"));
ASSERT_EQ(expected, result);
delete context;
}
@ -140,35 +139,35 @@ TEST_F(StringFunctionsTest, money_format_decimal_v2) {
TEST_F(StringFunctionsTest, split_part) {
doris_udf::FunctionContext* context = new doris_udf::FunctionContext();
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("hello")),
StringFunctions::split_part(context, StringVal("hello word"), StringVal(" "), 1));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("hello")),
StringFunctions::split_part(context, StringVal("hello word"), StringVal(" "), 1));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("word")),
StringFunctions::split_part(context, StringVal("hello word"), StringVal(" "), 2));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("word")),
StringFunctions::split_part(context, StringVal("hello word"), StringVal(" "), 2));
ASSERT_EQ(StringVal::null(),
StringFunctions::split_part(context, StringVal("hello word"), StringVal(" "), 3));
StringFunctions::split_part(context, StringVal("hello word"), StringVal(" "), 3));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("")),
StringFunctions::split_part(context, StringVal("hello word"), StringVal("hello"), 1));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("")),
StringFunctions::split_part(context, StringVal("hello word"), StringVal("hello"), 1));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string(" word")),
StringFunctions::split_part(context, StringVal("hello word"), StringVal("hello"), 2));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string(" word")),
StringFunctions::split_part(context, StringVal("hello word"), StringVal("hello"), 2));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("2019年9")),
StringFunctions::split_part(context, StringVal("2019年9月8日"), StringVal("月"), 1));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("2019年9")),
StringFunctions::split_part(context, StringVal("2019年9月8日"), StringVal("月"), 1));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("")),
StringFunctions::split_part(context, StringVal("abcdabda"), StringVal("a"), 1));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("")),
StringFunctions::split_part(context, StringVal("abcdabda"), StringVal("a"), 1));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("bcd")),
StringFunctions::split_part(context, StringVal("abcdabda"), StringVal("a"), 2));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("bcd")),
StringFunctions::split_part(context, StringVal("abcdabda"), StringVal("a"), 2));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("bd")),
StringFunctions::split_part(context, StringVal("abcdabda"), StringVal("a"), 3));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("bd")),
StringFunctions::split_part(context, StringVal("abcdabda"), StringVal("a"), 3));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("")),
StringFunctions::split_part(context, StringVal("abcdabda"), StringVal("a"), 4));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("")),
StringFunctions::split_part(context, StringVal("abcdabda"), StringVal("a"), 4));
delete context;
}
@ -192,11 +191,14 @@ TEST_F(StringFunctionsTest, ends_with) {
ASSERT_EQ(falseRet, StringFunctions::ends_with(context, StringVal(" "), StringVal("hello")));
ASSERT_EQ(falseRet, StringFunctions::ends_with(context, StringVal("hello doris"), StringVal("hello")));
ASSERT_EQ(falseRet,
StringFunctions::ends_with(context, StringVal("hello doris"), StringVal("hello")));
ASSERT_EQ(trueRet, StringFunctions::ends_with(context, StringVal("hello doris"), StringVal("doris")));
ASSERT_EQ(trueRet,
StringFunctions::ends_with(context, StringVal("hello doris"), StringVal("doris")));
ASSERT_EQ(trueRet, StringFunctions::ends_with(context, StringVal("hello doris"), StringVal("hello doris")));
ASSERT_EQ(trueRet, StringFunctions::ends_with(context, StringVal("hello doris"),
StringVal("hello doris")));
ASSERT_EQ(nullRet, StringFunctions::ends_with(context, StringVal("hello"), StringVal::null()));
@ -220,21 +222,27 @@ TEST_F(StringFunctionsTest, starts_with) {
ASSERT_EQ(falseRet, StringFunctions::starts_with(context, StringVal(""), StringVal("hello")));
ASSERT_EQ(trueRet, StringFunctions::starts_with(context, StringVal("hello"), StringVal("hello")));
ASSERT_EQ(trueRet,
StringFunctions::starts_with(context, StringVal("hello"), StringVal("hello")));
ASSERT_EQ(falseRet, StringFunctions::starts_with(context, StringVal("hello"), StringVal(" ")));
ASSERT_EQ(falseRet, StringFunctions::starts_with(context, StringVal(" "), StringVal("world")));
ASSERT_EQ(trueRet, StringFunctions::starts_with(context, StringVal("hello world"), StringVal("hello")));
ASSERT_EQ(trueRet,
StringFunctions::starts_with(context, StringVal("hello world"), StringVal("hello")));
ASSERT_EQ(falseRet, StringFunctions::starts_with(context, StringVal("hello world"), StringVal("world")));
ASSERT_EQ(falseRet,
StringFunctions::starts_with(context, StringVal("hello world"), StringVal("world")));
ASSERT_EQ(trueRet, StringFunctions::starts_with(context, StringVal("hello world"), StringVal("hello world")));
ASSERT_EQ(trueRet, StringFunctions::starts_with(context, StringVal("hello world"),
StringVal("hello world")));
ASSERT_EQ(nullRet, StringFunctions::starts_with(context, StringVal("hello world"), StringVal::null()));
ASSERT_EQ(nullRet,
StringFunctions::starts_with(context, StringVal("hello world"), StringVal::null()));
ASSERT_EQ(nullRet, StringFunctions::starts_with(context, StringVal::null(), StringVal("hello world")));
ASSERT_EQ(nullRet,
StringFunctions::starts_with(context, StringVal::null(), StringVal("hello world")));
ASSERT_EQ(nullRet, StringFunctions::starts_with(context, StringVal::null(), StringVal::null()));
delete context;
@ -264,98 +272,90 @@ TEST_F(StringFunctionsTest, null_or_empty) {
TEST_F(StringFunctionsTest, substring) {
doris_udf::FunctionContext* context = new doris_udf::FunctionContext();
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("hello")),
StringFunctions::substring(context, StringVal("hello word"), 1, 5));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("hello")),
StringFunctions::substring(context, StringVal("hello word"), 1, 5));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("word")),
StringFunctions::substring(context, StringVal("hello word"), 7, 4));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("word")),
StringFunctions::substring(context, StringVal("hello word"), 7, 4));
ASSERT_EQ(StringVal::null(),
StringFunctions::substring(context, StringVal::null(), 1, 0));
ASSERT_EQ(StringVal::null(), StringFunctions::substring(context, StringVal::null(), 1, 0));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("")),
StringFunctions::substring(context, StringVal("hello word"), 1, 0));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("")),
StringFunctions::substring(context, StringVal("hello word"), 1, 0));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string(" word")),
StringFunctions::substring(context, StringVal("hello word"), -5, 5));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string(" word")),
StringFunctions::substring(context, StringVal("hello word"), -5, 5));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("hello word 你")),
StringFunctions::substring(context, StringVal("hello word 你好"), 1, 12));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("hello word 你")),
StringFunctions::substring(context, StringVal("hello word 你好"), 1, 12));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("好")),
StringFunctions::substring(context, StringVal("hello word 你好"), 13, 1));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("好")),
StringFunctions::substring(context, StringVal("hello word 你好"), 13, 1));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("")),
StringFunctions::substring(context, StringVal("hello word 你好"), 1, 0));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("")),
StringFunctions::substring(context, StringVal("hello word 你好"), 1, 0));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("rd 你好")),
StringFunctions::substring(context, StringVal("hello word 你好"), -5, 5));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("rd 你好")),
StringFunctions::substring(context, StringVal("hello word 你好"), -5, 5));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("h")),
StringFunctions::substring(context, StringVal("hello word 你好"), 1, 1));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("h")),
StringFunctions::substring(context, StringVal("hello word 你好"), 1, 1));
delete context;
}
TEST_F(StringFunctionsTest, reverse) {
FunctionUtils fu;
doris_udf::FunctionContext* context = fu.get_fn_ctx();
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("olleh")),
StringFunctions::reverse(context, StringVal("hello")));
ASSERT_EQ(StringVal::null(),
StringFunctions::reverse(context, StringVal::null()));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("olleh")),
StringFunctions::reverse(context, StringVal("hello")));
ASSERT_EQ(StringVal::null(), StringFunctions::reverse(context, StringVal::null()));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("")),
StringFunctions::reverse(context, StringVal("")));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("")),
StringFunctions::reverse(context, StringVal("")));
ASSERT_EQ(AnyValUtil::from_string_temp(context,std::string("好你olleh")),
StringFunctions::reverse(context, StringVal("hello你好")));
ASSERT_EQ(AnyValUtil::from_string_temp(context, std::string("好你olleh")),
StringFunctions::reverse(context, StringVal("hello你好")));
}
TEST_F(StringFunctionsTest, length) {
doris_udf::FunctionContext* context = new doris_udf::FunctionContext();
ASSERT_EQ(IntVal(5),
StringFunctions::length(context, StringVal("hello")));
ASSERT_EQ(IntVal(5),
StringFunctions::char_utf8_length(context, StringVal("hello")));
ASSERT_EQ(IntVal::null(),
StringFunctions::length(context, StringVal::null()));
ASSERT_EQ(IntVal::null(),
StringFunctions::char_utf8_length(context, StringVal::null()));
ASSERT_EQ(IntVal(5), StringFunctions::length(context, StringVal("hello")));
ASSERT_EQ(IntVal(5), StringFunctions::char_utf8_length(context, StringVal("hello")));
ASSERT_EQ(IntVal::null(), StringFunctions::length(context, StringVal::null()));
ASSERT_EQ(IntVal::null(), StringFunctions::char_utf8_length(context, StringVal::null()));
ASSERT_EQ(IntVal(0),
StringFunctions::length(context, StringVal("")));
ASSERT_EQ(IntVal(0),
StringFunctions::char_utf8_length(context, StringVal("")));
ASSERT_EQ(IntVal(0), StringFunctions::length(context, StringVal("")));
ASSERT_EQ(IntVal(0), StringFunctions::char_utf8_length(context, StringVal("")));
ASSERT_EQ(IntVal(11),
StringFunctions::length(context, StringVal("hello你好")));
ASSERT_EQ(IntVal(11), StringFunctions::length(context, StringVal("hello你好")));
ASSERT_EQ(IntVal(7),
StringFunctions::char_utf8_length(context, StringVal("hello你好")));
ASSERT_EQ(IntVal(7), StringFunctions::char_utf8_length(context, StringVal("hello你好")));
delete context;
}
TEST_F(StringFunctionsTest, append_trailing_char_if_absent) {
ASSERT_EQ(StringVal("ac"), StringFunctions::append_trailing_char_if_absent(ctx,
StringVal("a"), StringVal("c")));
ASSERT_EQ(StringVal("ac"),
StringFunctions::append_trailing_char_if_absent(ctx, StringVal("a"), StringVal("c")));
ASSERT_EQ(StringVal("c"), StringFunctions::append_trailing_char_if_absent(ctx,
StringVal("c"), StringVal("c")));
ASSERT_EQ(StringVal("c"),
StringFunctions::append_trailing_char_if_absent(ctx, StringVal("c"), StringVal("c")));
ASSERT_EQ(StringVal("123c"), StringFunctions::append_trailing_char_if_absent(ctx,
StringVal("123c"), StringVal("c")));
ASSERT_EQ(StringVal("123c"), StringFunctions::append_trailing_char_if_absent(
ctx, StringVal("123c"), StringVal("c")));
ASSERT_EQ(StringVal("c"), StringFunctions::append_trailing_char_if_absent(ctx,
StringVal(""), StringVal("c")));
ASSERT_EQ(StringVal("c"),
StringFunctions::append_trailing_char_if_absent(ctx, StringVal(""), StringVal("c")));
ASSERT_EQ(StringVal::null(), StringFunctions::append_trailing_char_if_absent(ctx,
StringVal::null(), StringVal("c")));
ASSERT_EQ(StringVal::null(), StringFunctions::append_trailing_char_if_absent(
ctx, StringVal::null(), StringVal("c")));
ASSERT_EQ(StringVal::null(), StringFunctions::append_trailing_char_if_absent(ctx,
StringVal("a"), StringVal::null()));
ASSERT_EQ(StringVal::null(), StringFunctions::append_trailing_char_if_absent(
ctx, StringVal("a"), StringVal::null()));
ASSERT_EQ(StringVal::null(), StringFunctions::append_trailing_char_if_absent(ctx,
StringVal("a"), StringVal("abc")));
ASSERT_EQ(StringVal::null(), StringFunctions::append_trailing_char_if_absent(
ctx, StringVal("a"), StringVal("abc")));
}
TEST_F(StringFunctionsTest, instr) {
@ -374,77 +374,127 @@ TEST_F(StringFunctionsTest, instr) {
ASSERT_EQ(IntVal(3), StringFunctions::instr(context, StringVal("你好abc"), StringVal("abc")));
ASSERT_EQ(IntVal::null(), StringFunctions::instr(context, StringVal::null(), StringVal("2")));
ASSERT_EQ(IntVal::null(), StringFunctions::instr(context, StringVal(""), StringVal::null()));
ASSERT_EQ(IntVal::null(), StringFunctions::instr(context, StringVal::null(), StringVal::null()));
ASSERT_EQ(IntVal::null(),
StringFunctions::instr(context, StringVal::null(), StringVal::null()));
delete context;
}
TEST_F(StringFunctionsTest, locate) {
doris_udf::FunctionContext* context = new doris_udf::FunctionContext();
ASSERT_EQ(IntVal(4), StringFunctions::locate(context, StringVal("bar"), StringVal("foobarbar")));
ASSERT_EQ(IntVal(4),
StringFunctions::locate(context, StringVal("bar"), StringVal("foobarbar")));
ASSERT_EQ(IntVal(0), StringFunctions::locate(context, StringVal("xbar"), StringVal("foobar")));
ASSERT_EQ(IntVal(2), StringFunctions::locate(context, StringVal("234"), StringVal("123456234")));
ASSERT_EQ(IntVal(2),
StringFunctions::locate(context, StringVal("234"), StringVal("123456234")));
ASSERT_EQ(IntVal(0), StringFunctions::locate(context, StringVal("567"), StringVal("123456")));
ASSERT_EQ(IntVal(2), StringFunctions::locate(context, StringVal(".234"), StringVal("1.234")));
ASSERT_EQ(IntVal(1), StringFunctions::locate(context, StringVal(""), StringVal("1.234")));
ASSERT_EQ(IntVal(0), StringFunctions::locate(context, StringVal("123"), StringVal("")));
ASSERT_EQ(IntVal(1), StringFunctions::locate(context, StringVal(""), StringVal("")));
ASSERT_EQ(IntVal(3), StringFunctions::locate(context, StringVal("世界"), StringVal("你好世界")));
ASSERT_EQ(IntVal(0), StringFunctions::locate(context, StringVal("您好"), StringVal("你好世界")));
ASSERT_EQ(IntVal(3),
StringFunctions::locate(context, StringVal("世界"), StringVal("你好世界")));
ASSERT_EQ(IntVal(0),
StringFunctions::locate(context, StringVal("您好"), StringVal("你好世界")));
ASSERT_EQ(IntVal(3), StringFunctions::locate(context, StringVal("a"), StringVal("你好abc")));
ASSERT_EQ(IntVal(3), StringFunctions::locate(context, StringVal("abc"), StringVal("你好abc")));
ASSERT_EQ(IntVal::null(), StringFunctions::locate(context, StringVal::null(), StringVal("2")));
ASSERT_EQ(IntVal::null(), StringFunctions::locate(context, StringVal(""), StringVal::null()));
ASSERT_EQ(IntVal::null(), StringFunctions::locate(context, StringVal::null(), StringVal::null()));
ASSERT_EQ(IntVal::null(),
StringFunctions::locate(context, StringVal::null(), StringVal::null()));
delete context;
}
TEST_F(StringFunctionsTest, locate_pos) {
doris_udf::FunctionContext* context = new doris_udf::FunctionContext();
ASSERT_EQ(IntVal(7), StringFunctions::locate_pos(context, StringVal("bar"), StringVal("foobarbar"), IntVal(5)));
ASSERT_EQ(IntVal(0), StringFunctions::locate_pos(context, StringVal("xbar"), StringVal("foobar"), IntVal(1)));
ASSERT_EQ(IntVal(2), StringFunctions::locate_pos(context, StringVal(""), StringVal("foobar"), IntVal(2)));
ASSERT_EQ(IntVal(0), StringFunctions::locate_pos(context, StringVal("foobar"), StringVal(""), IntVal(1)));
ASSERT_EQ(IntVal(0), StringFunctions::locate_pos(context, StringVal(""), StringVal(""), IntVal(2)));
ASSERT_EQ(IntVal(0), StringFunctions::locate_pos(context, StringVal("A"), StringVal("AAAAAA"), IntVal(0)));
ASSERT_EQ(IntVal(0), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"), IntVal(0)));
ASSERT_EQ(IntVal(2), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"), IntVal(1)));
ASSERT_EQ(IntVal(2), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"), IntVal(2)));
ASSERT_EQ(IntVal(5), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"), IntVal(3)));
ASSERT_EQ(IntVal(7), StringFunctions::locate_pos(context, StringVal("BaR"), StringVal("foobarBaR"), IntVal(5)));
ASSERT_EQ(IntVal::null(), StringFunctions::locate_pos(context, StringVal::null(), StringVal("2"), IntVal(1)));
ASSERT_EQ(IntVal::null(), StringFunctions::locate_pos(context, StringVal(""), StringVal::null(), IntVal(4)));
ASSERT_EQ(IntVal::null(), StringFunctions::locate_pos(context, StringVal::null(), StringVal::null(), IntVal(4)));
ASSERT_EQ(IntVal::null(), StringFunctions::locate_pos(context, StringVal::null(), StringVal::null(), IntVal(-1)));
ASSERT_EQ(IntVal(7), StringFunctions::locate_pos(context, StringVal("bar"),
StringVal("foobarbar"), IntVal(5)));
ASSERT_EQ(IntVal(0), StringFunctions::locate_pos(context, StringVal("xbar"),
StringVal("foobar"), IntVal(1)));
ASSERT_EQ(IntVal(2),
StringFunctions::locate_pos(context, StringVal(""), StringVal("foobar"), IntVal(2)));
ASSERT_EQ(IntVal(0),
StringFunctions::locate_pos(context, StringVal("foobar"), StringVal(""), IntVal(1)));
ASSERT_EQ(IntVal(0),
StringFunctions::locate_pos(context, StringVal(""), StringVal(""), IntVal(2)));
ASSERT_EQ(IntVal(0),
StringFunctions::locate_pos(context, StringVal("A"), StringVal("AAAAAA"), IntVal(0)));
ASSERT_EQ(IntVal(0), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"),
IntVal(0)));
ASSERT_EQ(IntVal(2), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"),
IntVal(1)));
ASSERT_EQ(IntVal(2), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"),
IntVal(2)));
ASSERT_EQ(IntVal(5), StringFunctions::locate_pos(context, StringVal("A"), StringVal("大A写的A"),
IntVal(3)));
ASSERT_EQ(IntVal(7), StringFunctions::locate_pos(context, StringVal("BaR"),
StringVal("foobarBaR"), IntVal(5)));
ASSERT_EQ(IntVal::null(),
StringFunctions::locate_pos(context, StringVal::null(), StringVal("2"), IntVal(1)));
ASSERT_EQ(IntVal::null(),
StringFunctions::locate_pos(context, StringVal(""), StringVal::null(), IntVal(4)));
ASSERT_EQ(IntVal::null(), StringFunctions::locate_pos(context, StringVal::null(),
StringVal::null(), IntVal(4)));
ASSERT_EQ(IntVal::null(), StringFunctions::locate_pos(context, StringVal::null(),
StringVal::null(), IntVal(-1)));
delete context;
}
TEST_F(StringFunctionsTest, lpad) {
ASSERT_EQ(StringVal("???hi"), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(5), StringVal("?")));
ASSERT_EQ(StringVal("g8%7IgY%AHx7luNtf8Kh"), StringFunctions::lpad(ctx, StringVal("g8%7IgY%AHx7luNtf8Kh"), IntVal(20), StringVal("")));
ASSERT_EQ(StringVal("h"), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(1), StringVal("?")));
ASSERT_EQ(StringVal("你"), StringFunctions::lpad(ctx, StringVal("你好"), IntVal(1), StringVal("?")));
ASSERT_EQ(StringVal(""), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(0), StringVal("?")));
ASSERT_EQ(StringVal::null(), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(-1), StringVal("?")));
ASSERT_EQ(StringVal("h"), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(1), StringVal("")));
ASSERT_EQ(StringVal::null(), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(5), StringVal("")));
ASSERT_EQ(StringVal("abahi"), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(5), StringVal("ab")));
ASSERT_EQ(StringVal("ababhi"), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(6), StringVal("ab")));
ASSERT_EQ(StringVal("呵呵呵hi"), StringFunctions::lpad(ctx, StringVal("hi"), IntVal(5), StringVal("呵呵")));
ASSERT_EQ(StringVal("hih呵呵"), StringFunctions::lpad(ctx, StringVal("呵呵"), IntVal(5), StringVal("hi")));
ASSERT_EQ(StringVal("???hi"),
StringFunctions::lpad(ctx, StringVal("hi"), IntVal(5), StringVal("?")));
ASSERT_EQ(StringVal("g8%7IgY%AHx7luNtf8Kh"),
StringFunctions::lpad(ctx, StringVal("g8%7IgY%AHx7luNtf8Kh"), IntVal(20),
StringVal("")));
ASSERT_EQ(StringVal("h"),
StringFunctions::lpad(ctx, StringVal("hi"), IntVal(1), StringVal("?")));
ASSERT_EQ(StringVal("你"),
StringFunctions::lpad(ctx, StringVal("你好"), IntVal(1), StringVal("?")));
ASSERT_EQ(StringVal(""),
StringFunctions::lpad(ctx, StringVal("hi"), IntVal(0), StringVal("?")));
ASSERT_EQ(StringVal::null(),
StringFunctions::lpad(ctx, StringVal("hi"), IntVal(-1), StringVal("?")));
ASSERT_EQ(StringVal("h"),
StringFunctions::lpad(ctx, StringVal("hi"), IntVal(1), StringVal("")));
ASSERT_EQ(StringVal::null(),
StringFunctions::lpad(ctx, StringVal("hi"), IntVal(5), StringVal("")));
ASSERT_EQ(StringVal("abahi"),
StringFunctions::lpad(ctx, StringVal("hi"), IntVal(5), StringVal("ab")));
ASSERT_EQ(StringVal("ababhi"),
StringFunctions::lpad(ctx, StringVal("hi"), IntVal(6), StringVal("ab")));
ASSERT_EQ(StringVal("呵呵呵hi"),
StringFunctions::lpad(ctx, StringVal("hi"), IntVal(5), StringVal("呵呵")));
ASSERT_EQ(StringVal("hih呵呵"),
StringFunctions::lpad(ctx, StringVal("呵呵"), IntVal(5), StringVal("hi")));
}
TEST_F(StringFunctionsTest, rpad) {
ASSERT_EQ(StringVal("hi???"), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(5), StringVal("?")));
ASSERT_EQ(StringVal("g8%7IgY%AHx7luNtf8Kh"), StringFunctions::rpad(ctx, StringVal("g8%7IgY%AHx7luNtf8Kh"), IntVal(20), StringVal("")));
ASSERT_EQ(StringVal("h"), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(1), StringVal("?")));
ASSERT_EQ(StringVal("你"), StringFunctions::rpad(ctx, StringVal("你好"), IntVal(1), StringVal("?")));
ASSERT_EQ(StringVal(""), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(0), StringVal("?")));
ASSERT_EQ(StringVal::null(), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(-1), StringVal("?")));
ASSERT_EQ(StringVal("h"), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(1), StringVal("")));
ASSERT_EQ(StringVal::null(), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(5), StringVal("")));
ASSERT_EQ(StringVal("hiaba"), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(5), StringVal("ab")));
ASSERT_EQ(StringVal("hiabab"), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(6), StringVal("ab")));
ASSERT_EQ(StringVal("hi呵呵呵"), StringFunctions::rpad(ctx, StringVal("hi"), IntVal(5), StringVal("呵呵")));
ASSERT_EQ(StringVal("呵呵hih"), StringFunctions::rpad(ctx, StringVal("呵呵"), IntVal(5), StringVal("hi")));
}
ASSERT_EQ(StringVal("hi???"),
StringFunctions::rpad(ctx, StringVal("hi"), IntVal(5), StringVal("?")));
ASSERT_EQ(StringVal("g8%7IgY%AHx7luNtf8Kh"),
StringFunctions::rpad(ctx, StringVal("g8%7IgY%AHx7luNtf8Kh"), IntVal(20),
StringVal("")));
ASSERT_EQ(StringVal("h"),
StringFunctions::rpad(ctx, StringVal("hi"), IntVal(1), StringVal("?")));
ASSERT_EQ(StringVal("你"),
StringFunctions::rpad(ctx, StringVal("你好"), IntVal(1), StringVal("?")));
ASSERT_EQ(StringVal(""),
StringFunctions::rpad(ctx, StringVal("hi"), IntVal(0), StringVal("?")));
ASSERT_EQ(StringVal::null(),
StringFunctions::rpad(ctx, StringVal("hi"), IntVal(-1), StringVal("?")));
ASSERT_EQ(StringVal("h"),
StringFunctions::rpad(ctx, StringVal("hi"), IntVal(1), StringVal("")));
ASSERT_EQ(StringVal::null(),
StringFunctions::rpad(ctx, StringVal("hi"), IntVal(5), StringVal("")));
ASSERT_EQ(StringVal("hiaba"),
StringFunctions::rpad(ctx, StringVal("hi"), IntVal(5), StringVal("ab")));
ASSERT_EQ(StringVal("hiabab"),
StringFunctions::rpad(ctx, StringVal("hi"), IntVal(6), StringVal("ab")));
ASSERT_EQ(StringVal("hi呵呵呵"),
StringFunctions::rpad(ctx, StringVal("hi"), IntVal(5), StringVal("呵呵")));
ASSERT_EQ(StringVal("呵呵hih"),
StringFunctions::rpad(ctx, StringVal("呵呵"), IntVal(5), StringVal("hi")));
}
} // namespace doris
int main(int argc, char** argv) {
std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf";

191
be/test/util/system_metrics_test.cpp
View File

@ -29,16 +29,14 @@ namespace doris {
class SystemMetricsTest : public testing::Test {
public:
SystemMetricsTest() { }
virtual ~SystemMetricsTest() {
}
SystemMetricsTest() {}
virtual ~SystemMetricsTest() {}
};
class TestMetricsVisitor : public MetricsVisitor {
public:
virtual ~TestMetricsVisitor() { }
void visit(const std::string& prefix, const std::string& name,
MetricCollector* collector) {
virtual ~TestMetricsVisitor() {}
void visit(const std::string& prefix, const std::string& name, MetricCollector* collector) {
for (auto& it : collector->metrics()) {
Metric* metric = it.second;
auto& labels = it.first;
@ -73,9 +71,8 @@ public:
}
}
}
std::string to_string() {
return _ss.str();
}
std::string to_string() { return _ss.str(); }
private:
std::stringstream _ss;
};
@ -87,28 +84,28 @@ extern const char* k_ut_fd_path;
extern const char* k_ut_net_snmp_path;
TEST_F(SystemMetricsTest, normal) {
char buf[1024];
readlink("/proc/self/exe", buf, 1023);
char* dir_path = dirname(buf);
std::string stat_path(dir_path);
stat_path += "/test_data/stat_normal";
LOG(INFO) << stat_path;
k_ut_stat_path = stat_path.c_str();
std::string diskstats_path(dir_path);
diskstats_path += "/test_data/diskstats_normal";
k_ut_diskstats_path = diskstats_path.c_str();
std::string net_dev_path(dir_path);
net_dev_path += "/test_data/net_dev_normal";
k_ut_net_dev_path = net_dev_path.c_str();
std::string fd_path(dir_path);
fd_path += "/test_data/fd_file_nr";
k_ut_fd_path = fd_path.c_str();
std::string net_snmp_path(dir_path);
net_snmp_path += "/test_data/net_snmp_normal";
k_ut_net_snmp_path = net_snmp_path.c_str();
MetricRegistry registry("test");
{
char buf[1024];
readlink("/proc/self/exe", buf, 1023);
char* dir_path = dirname(buf);
std::string stat_path(dir_path);
stat_path += "/test_data/stat_normal";
LOG(INFO) << stat_path;
k_ut_stat_path = stat_path.c_str();
std::string diskstats_path(dir_path);
diskstats_path += "/test_data/diskstats_normal";
k_ut_diskstats_path = diskstats_path.c_str();
std::string net_dev_path(dir_path);
net_dev_path += "/test_data/net_dev_normal";
k_ut_net_dev_path = net_dev_path.c_str();
std::string fd_path(dir_path);
fd_path += "/test_data/fd_file_nr";
k_ut_fd_path = fd_path.c_str();
std::string net_snmp_path(dir_path);
net_snmp_path += "/test_data/net_snmp_normal";
k_ut_net_snmp_path = net_snmp_path.c_str();
std::set<std::string> disk_devices;
disk_devices.emplace("sda");
std::vector<std::string> network_interfaces;
@ -122,112 +119,102 @@ TEST_F(SystemMetricsTest, normal) {
LOG(INFO) << "\n" << visitor.to_string();
// cpu
Metric* cpu_user = registry.get_metric(
"cpu", MetricLabels().add("mode", "user"));
Metric* cpu_user = registry.get_metric("cpu", MetricLabels().add("mode", "user"));
ASSERT_TRUE(cpu_user != nullptr);
// ASSERT_STREQ("57199151", cpu_user->to_string().c_str());
Metric* cpu_nice = registry.get_metric(
"cpu", MetricLabels().add("mode", "nice"));
Metric* cpu_nice = registry.get_metric("cpu", MetricLabels().add("mode", "nice"));
ASSERT_TRUE(cpu_nice != nullptr);
ASSERT_STREQ("2616310", cpu_nice->to_string().c_str());
Metric* cpu_system = registry.get_metric(
"cpu", MetricLabels().add("mode", "system"));
Metric* cpu_system = registry.get_metric("cpu", MetricLabels().add("mode", "system"));
ASSERT_TRUE(cpu_system != nullptr);
ASSERT_STREQ("10600935", cpu_system->to_string().c_str());
Metric* cpu_idle = registry.get_metric(
"cpu", MetricLabels().add("mode", "idle"));
Metric* cpu_idle = registry.get_metric("cpu", MetricLabels().add("mode", "idle"));
ASSERT_TRUE(cpu_idle != nullptr);
ASSERT_STREQ("1517505423", cpu_idle->to_string().c_str());
Metric* cpu_iowait = registry.get_metric(
"cpu", MetricLabels().add("mode", "iowait"));
Metric* cpu_iowait = registry.get_metric("cpu", MetricLabels().add("mode", "iowait"));
ASSERT_TRUE(cpu_iowait != nullptr);
ASSERT_STREQ("2137148", cpu_iowait->to_string().c_str());
Metric* cpu_irq = registry.get_metric(
"cpu", MetricLabels().add("mode", "irq"));
Metric* cpu_irq = registry.get_metric("cpu", MetricLabels().add("mode", "irq"));
ASSERT_TRUE(cpu_irq != nullptr);
ASSERT_STREQ("0", cpu_irq->to_string().c_str());
Metric* cpu_softirq = registry.get_metric(
"cpu", MetricLabels().add("mode", "soft_irq"));
Metric* cpu_softirq = registry.get_metric("cpu", MetricLabels().add("mode", "soft_irq"));
ASSERT_TRUE(cpu_softirq != nullptr);
ASSERT_STREQ("108277", cpu_softirq->to_string().c_str());
Metric* cpu_steal = registry.get_metric(
"cpu", MetricLabels().add("mode", "steal"));
Metric* cpu_steal = registry.get_metric("cpu", MetricLabels().add("mode", "steal"));
ASSERT_TRUE(cpu_steal != nullptr);
ASSERT_STREQ("0", cpu_steal->to_string().c_str());
Metric* cpu_guest = registry.get_metric(
"cpu", MetricLabels().add("mode", "guest"));
Metric* cpu_guest = registry.get_metric("cpu", MetricLabels().add("mode", "guest"));
ASSERT_TRUE(cpu_guest != nullptr);
ASSERT_STREQ("0", cpu_guest->to_string().c_str());
// memroy
Metric* memory_allocated_bytes = registry.get_metric(
"memory_allocated_bytes");
Metric* memory_allocated_bytes = registry.get_metric("memory_allocated_bytes");
ASSERT_TRUE(memory_allocated_bytes != nullptr);
// network
Metric* receive_bytes = registry.get_metric(
"network_receive_bytes", MetricLabels().add("device", "xgbe0"));
Metric* receive_bytes =
registry.get_metric("network_receive_bytes", MetricLabels().add("device", "xgbe0"));
ASSERT_TRUE(receive_bytes != nullptr);
ASSERT_STREQ("52567436039", receive_bytes->to_string().c_str());
Metric* receive_packets = registry.get_metric(
"network_receive_packets", MetricLabels().add("device", "xgbe0"));
Metric* receive_packets = registry.get_metric("network_receive_packets",
MetricLabels().add("device", "xgbe0"));
ASSERT_TRUE(receive_packets != nullptr);
ASSERT_STREQ("65066152", receive_packets->to_string().c_str());
Metric* send_bytes = registry.get_metric(
"network_send_bytes", MetricLabels().add("device", "xgbe0"));
Metric* send_bytes =
registry.get_metric("network_send_bytes", MetricLabels().add("device", "xgbe0"));
ASSERT_TRUE(send_bytes != nullptr);
ASSERT_STREQ("45480856156", send_bytes->to_string().c_str());
Metric* send_packets = registry.get_metric(
"network_send_packets", MetricLabels().add("device", "xgbe0"));
Metric* send_packets =
registry.get_metric("network_send_packets", MetricLabels().add("device", "xgbe0"));
ASSERT_TRUE(send_packets != nullptr);
ASSERT_STREQ("88277614", send_packets->to_string().c_str());
// disk
Metric* bytes_read = registry.get_metric(
"disk_bytes_read", MetricLabels().add("device", "sda"));
Metric* bytes_read =
registry.get_metric("disk_bytes_read", MetricLabels().add("device", "sda"));
ASSERT_TRUE(bytes_read != nullptr);
ASSERT_STREQ("20142745600", bytes_read->to_string().c_str());
Metric* reads_completed = registry.get_metric(
"disk_reads_completed", MetricLabels().add("device", "sda"));
Metric* reads_completed =
registry.get_metric("disk_reads_completed", MetricLabels().add("device", "sda"));
ASSERT_TRUE(reads_completed != nullptr);
ASSERT_STREQ("759548", reads_completed->to_string().c_str());
Metric* read_time_ms = registry.get_metric(
"disk_read_time_ms", MetricLabels().add("device", "sda"));
Metric* read_time_ms =
registry.get_metric("disk_read_time_ms", MetricLabels().add("device", "sda"));
ASSERT_TRUE(read_time_ms != nullptr);
ASSERT_STREQ("4308146", read_time_ms->to_string().c_str());
Metric* bytes_written = registry.get_metric(
"disk_bytes_written", MetricLabels().add("device", "sda"));
Metric* bytes_written =
registry.get_metric("disk_bytes_written", MetricLabels().add("device", "sda"));
ASSERT_TRUE(bytes_written != nullptr);
ASSERT_STREQ("1624753500160", bytes_written->to_string().c_str());
Metric* writes_completed = registry.get_metric(
"disk_writes_completed", MetricLabels().add("device", "sda"));
Metric* writes_completed =
registry.get_metric("disk_writes_completed", MetricLabels().add("device", "sda"));
ASSERT_TRUE(writes_completed != nullptr);
ASSERT_STREQ("18282936", writes_completed->to_string().c_str());
Metric* write_time_ms = registry.get_metric(
"disk_write_time_ms", MetricLabels().add("device", "sda"));
Metric* write_time_ms =
registry.get_metric("disk_write_time_ms", MetricLabels().add("device", "sda"));
ASSERT_TRUE(write_time_ms != nullptr);
ASSERT_STREQ("1907755230", write_time_ms->to_string().c_str());
Metric* io_time_ms = registry.get_metric(
"disk_io_time_ms", MetricLabels().add("device", "sda"));
Metric* io_time_ms =
registry.get_metric("disk_io_time_ms", MetricLabels().add("device", "sda"));
ASSERT_TRUE(io_time_ms != nullptr);
ASSERT_STREQ("19003350", io_time_ms->to_string().c_str());
Metric* io_time_weigthed = registry.get_metric(
"disk_io_time_weigthed", MetricLabels().add("device", "sda"));
Metric* io_time_weigthed =
registry.get_metric("disk_io_time_weigthed", MetricLabels().add("device", "sda"));
ASSERT_TRUE(write_time_ms != nullptr);
ASSERT_STREQ("1912122964", io_time_weigthed->to_string().c_str());
// fd
Metric* fd_metric = registry.get_metric(
"fd_num_limit");
Metric* fd_metric = registry.get_metric("fd_num_limit");
ASSERT_TRUE(fd_metric != nullptr);
ASSERT_STREQ("13052138", fd_metric->to_string().c_str());
fd_metric = registry.get_metric(
"fd_num_used");
fd_metric = registry.get_metric("fd_num_used");
ASSERT_TRUE(fd_metric != nullptr);
ASSERT_STREQ("19520", fd_metric->to_string().c_str());
// net snmp
Metric* tcp_retrans_segs = registry.get_metric("snmp", MetricLabels().add("name", "tcp_retrans_segs"));
Metric* tcp_retrans_segs =
registry.get_metric("snmp", MetricLabels().add("name", "tcp_retrans_segs"));
ASSERT_TRUE(tcp_retrans_segs != nullptr);
Metric* tcp_in_errs = registry.get_metric("snmp", MetricLabels().add("name","tcp_in_errs"));
Metric* tcp_in_errs =
registry.get_metric("snmp", MetricLabels().add("name", "tcp_in_errs"));
ASSERT_TRUE(tcp_in_errs != nullptr);
ASSERT_STREQ("826271", tcp_retrans_segs->to_string().c_str());
ASSERT_STREQ("12712", tcp_in_errs->to_string().c_str());
@ -247,22 +234,24 @@ TEST_F(SystemMetricsTest, normal) {
}
TEST_F(SystemMetricsTest, no_proc_file) {
char buf[1024];
readlink("/proc/self/exe", buf, 1023);
char* dir_path = dirname(buf);
std::string stat_path(dir_path);
stat_path += "/test_data/no_stat_normal";
LOG(INFO) << stat_path;
k_ut_stat_path = stat_path.c_str();
std::string diskstats_path(dir_path);
diskstats_path += "/test_data/no_diskstats_normal";
k_ut_diskstats_path = diskstats_path.c_str();
std::string net_dev_path(dir_path);
net_dev_path += "/test_data/no_net_dev_normal";
k_ut_net_dev_path = net_dev_path.c_str();
k_ut_fd_path = "";
k_ut_net_snmp_path = "";
MetricRegistry registry("test");
{
char buf[1024];
readlink("/proc/self/exe", buf, 1023);
char* dir_path = dirname(buf);
std::string stat_path(dir_path);
stat_path += "/test_data/no_stat_normal";
LOG(INFO) << stat_path;
k_ut_stat_path = stat_path.c_str();
std::string diskstats_path(dir_path);
diskstats_path += "/test_data/no_diskstats_normal";
k_ut_diskstats_path = diskstats_path.c_str();
std::string net_dev_path(dir_path);
net_dev_path += "/test_data/no_net_dev_normal";
k_ut_net_dev_path = net_dev_path.c_str();
std::set<std::string> disk_devices;
disk_devices.emplace("sda");
std::vector<std::string> network_interfaces;
@ -275,28 +264,26 @@ TEST_F(SystemMetricsTest, no_proc_file) {
LOG(INFO) << "\n" << visitor.to_string();
// cpu
Metric* cpu_user = registry.get_metric(
"cpu", MetricLabels().add("mode", "user"));
Metric* cpu_user = registry.get_metric("cpu", MetricLabels().add("mode", "user"));
ASSERT_TRUE(cpu_user != nullptr);
ASSERT_STREQ("0", cpu_user->to_string().c_str());
// memroy
Metric* memory_allocated_bytes = registry.get_metric(
"memory_allocated_bytes");
Metric* memory_allocated_bytes = registry.get_metric("memory_allocated_bytes");
ASSERT_TRUE(memory_allocated_bytes != nullptr);
// network
Metric* receive_bytes = registry.get_metric(
"network_receive_bytes", MetricLabels().add("device", "xgbe0"));
Metric* receive_bytes =
registry.get_metric("network_receive_bytes", MetricLabels().add("device", "xgbe0"));
ASSERT_TRUE(receive_bytes != nullptr);
ASSERT_STREQ("0", receive_bytes->to_string().c_str());
// disk
Metric* bytes_read = registry.get_metric(
"disk_bytes_read", MetricLabels().add("device", "sda"));
Metric* bytes_read =
registry.get_metric("disk_bytes_read", MetricLabels().add("device", "sda"));
ASSERT_TRUE(bytes_read != nullptr);
ASSERT_STREQ("0", bytes_read->to_string().c_str());
}
}
}
} // namespace doris
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);

2
run-ut.sh
View File

@ -89,7 +89,7 @@ fi
cd ${DORIS_HOME}/be/ut_build/
${CMAKE_CMD} ../ -DWITH_MYSQL=OFF -DMAKE_TEST=ON -DCMAKE_BUILD_TYPE=DEBUG
${CMAKE_CMD} ../ -DWITH_MYSQL=OFF -DMAKE_TEST=ON -DCMAKE_BUILD_TYPE=ASAN
make -j${PARALLEL}
if [ ${RUN} -ne 1 ]; then