e4dc2ec440
StorageEngine::open just return a very vague status info when failed, we have to check logs to find out the root reason, and it's not convenient to check logs if we run unit tests in CI dockers. It would be better to return more detailed failure info to point out the root reason, for example, it may return error status with message "file descriptors limit is too small".
141 lines
4.5 KiB
C++
141 lines
4.5 KiB
C++
// Licensed to the Apache Software Foundation (ASF) under one
|
|
// or more contributor license agreements. See the NOTICE file
|
|
// distributed with this work for additional information
|
|
// regarding copyright ownership. The ASF licenses this file
|
|
// to you under the Apache License, Version 2.0 (the
|
|
// "License"); you may not use this file except in compliance
|
|
// with the License. You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing,
|
|
// software distributed under the License is distributed on an
|
|
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
// KIND, either express or implied. See the License for the
|
|
// specific language governing permissions and limitations
|
|
// under the License.
|
|
|
|
#include "olap/memtable_flush_executor.h"
|
|
|
|
#include <sys/file.h>
|
|
#include <string>
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "gen_cpp/Descriptors_types.h"
|
|
#include "gen_cpp/PaloInternalService_types.h"
|
|
#include "gen_cpp/Types_types.h"
|
|
#include "olap/delta_writer.h"
|
|
#include "olap/field.h"
|
|
#include "olap/memtable.h"
|
|
#include "olap/schema.h"
|
|
#include "olap/storage_engine.h"
|
|
#include "olap/tablet.h"
|
|
#include "olap/utils.h"
|
|
#include "runtime/tuple.h"
|
|
#include "runtime/descriptor_helper.h"
|
|
#include "runtime/exec_env.h"
|
|
#include "util/logging.h"
|
|
#include "util/file_utils.h"
|
|
#include "olap/options.h"
|
|
#include "olap/tablet_meta_manager.h"
|
|
|
|
namespace doris {
|
|
|
|
StorageEngine* k_engine = nullptr;
|
|
MemTableFlushExecutor* k_flush_executor = nullptr;
|
|
|
|
void set_up() {
|
|
char buffer[1024];
|
|
getcwd(buffer, 1024);
|
|
config::storage_root_path = std::string(buffer) + "/flush_test";
|
|
FileUtils::remove_all(config::storage_root_path);
|
|
FileUtils::create_dir(config::storage_root_path);
|
|
std::vector<StorePath> paths;
|
|
paths.emplace_back(config::storage_root_path, -1);
|
|
|
|
doris::EngineOptions options;
|
|
options.store_paths = paths;
|
|
Status s = doris::StorageEngine::open(options, &k_engine);
|
|
ASSERT_TRUE(s.ok()) << s.to_string();
|
|
|
|
ExecEnv* exec_env = doris::ExecEnv::GetInstance();
|
|
exec_env->set_storage_engine(k_engine);
|
|
|
|
k_flush_executor = k_engine->memtable_flush_executor();
|
|
}
|
|
|
|
void tear_down() {
|
|
delete k_engine;
|
|
k_engine = nullptr;
|
|
system("rm -rf ./flush_test");
|
|
FileUtils::remove_all(std::string(getenv("DORIS_HOME")) + UNUSED_PREFIX);
|
|
}
|
|
|
|
Schema create_schema() {
|
|
std::vector<TabletColumn> col_schemas;
|
|
col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_SMALLINT, true);
|
|
col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_INT, true);
|
|
col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_SUM, OLAP_FIELD_TYPE_BIGINT, true);
|
|
Schema schema(col_schemas, 2);
|
|
return schema;
|
|
}
|
|
|
|
class TestMemTableFlushExecutor : public ::testing::Test {
|
|
public:
|
|
TestMemTableFlushExecutor() { }
|
|
~TestMemTableFlushExecutor() { }
|
|
|
|
void SetUp() {
|
|
std::cout << "setup" << std::endl;
|
|
}
|
|
|
|
void TearDown(){
|
|
std::cout << "tear down" << std::endl;
|
|
}
|
|
};
|
|
|
|
TEST_F(TestMemTableFlushExecutor, create_flush_handler) {
|
|
std::vector<DataDir*> data_dir = k_engine->get_stores();
|
|
size_t path_hash = data_dir[0]->path_hash();
|
|
|
|
std::shared_ptr<FlushHandler> flush_handler;
|
|
k_flush_executor->create_flush_handler(path_hash, &flush_handler);
|
|
ASSERT_NE(nullptr, flush_handler.get());
|
|
|
|
FlushResult res;
|
|
res.flush_status = OLAP_SUCCESS;
|
|
res.flush_time_ns = 100;
|
|
flush_handler->on_flush_finished(res);
|
|
ASSERT_FALSE(flush_handler->is_cancelled());
|
|
ASSERT_EQ(100, flush_handler->get_stats().flush_time_ns);
|
|
ASSERT_EQ(1, flush_handler->get_stats().flush_count);
|
|
|
|
FlushResult res2;
|
|
res2.flush_status = OLAP_ERR_OTHER_ERROR;
|
|
flush_handler->on_flush_finished(res2);
|
|
ASSERT_TRUE(flush_handler->is_cancelled());
|
|
ASSERT_EQ(100, flush_handler->get_stats().flush_time_ns);
|
|
ASSERT_EQ(1, flush_handler->get_stats().flush_count);
|
|
|
|
ASSERT_EQ(OLAP_ERR_OTHER_ERROR, flush_handler->wait());
|
|
}
|
|
|
|
} // namespace doris
|
|
|
|
int main(int argc, char** argv) {
|
|
std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf";
|
|
if (!doris::config::init(conffile.c_str(), false)) {
|
|
fprintf(stderr, "error read config file. \n");
|
|
return -1;
|
|
}
|
|
doris::init_glog("be-test");
|
|
int ret = doris::OLAP_SUCCESS;
|
|
testing::InitGoogleTest(&argc, argv);
|
|
doris::CpuInfo::init();
|
|
doris::set_up();
|
|
ret = RUN_ALL_TESTS();
|
|
doris::tear_down();
|
|
google::protobuf::ShutdownProtobufLibrary();
|
|
return ret;
|
|
}
|