hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

[FEAT MERGE] log4100 branch

Browse Source 
Co-authored-by: tino247 <tino247@126.com>
Co-authored-by: BinChenn <binchenn.bc@gmail.com>
Co-authored-by: HaHaJeff <jeffzhouhhh@gmail.com>
This commit is contained in:
obdev
2023-01-28 18:17:31 +08:00
committed by ob-robot
parent a269ffe6be
commit 50024b39cd
772 changed files with 60275 additions and 11301 deletions
Download Patch File Download Diff File Expand all files Collapse all files

470
src/logservice/palf/palf_env_impl.cpp
View File

@ -11,6 +11,7 @@
*/
#include "palf_env_impl.h"
#include <string.h>
#include "lib/lock/ob_spin_lock.h"
#include "lib/ob_define.h"
#include "lib/ob_errno.h"
@ -22,7 +23,7 @@
#include "share/ob_errno.h"
#include "share/ob_occam_thread_pool.h"
#include "log_define.h"
#include "palf_handle_impl_guard.h" // PalfHandleImplGuard
#include "palf_handle_impl_guard.h" // IPalfHandleImplGuard
#include "palf_handle.h"
#include "log_loop_thread.h"
#include "log_rpc.h"
@ -36,15 +37,37 @@ namespace palf
{
PalfHandleImpl *PalfHandleImplFactory::alloc()
{
return op_reclaim_alloc(PalfHandleImpl);
return MTL_NEW(PalfHandleImpl, "palf_env");
}
void PalfHandleImplFactory::free(PalfHandleImpl *palf_handle_impl)
void PalfHandleImplFactory::free(IPalfHandleImpl *palf_handle_impl)
{
op_reclaim_free(palf_handle_impl);
MTL_DELETE(IPalfHandleImpl, "palf_env", palf_handle_impl);
}
PalfHandleImpl *PalfHandleImplAlloc::alloc_value()
{
return NULL;
}
void PalfHandleImplAlloc::free_value(IPalfHandleImpl *palf_handle_impl)
{
PalfHandleImplFactory::free(palf_handle_impl);
palf_handle_impl = NULL;
}
PalfHandleImplAlloc::Node *PalfHandleImplAlloc::alloc_node(IPalfHandleImpl *palf_handle_impl)
{
UNUSED(palf_handle_impl);
return op_reclaim_alloc(Node);
}
void PalfHandleImplAlloc::free_node(PalfHandleImplAlloc::Node *node)
{
op_reclaim_free(node);
node = NULL;
}
int PalfDiskOptionsWrapper::init(const PalfDiskOptions &disk_opts)
{
int ret = OB_SUCCESS;
@ -108,7 +131,6 @@ int PalfDiskOptionsWrapper::update_disk_options_not_guarded_by_lock_(const PalfD
return ret;
}
PalfEnvImpl::PalfEnvImpl() : palf_meta_lock_(common::ObLatchIds::PALF_ENV_LOCK),
log_alloc_mgr_(NULL),
log_block_pool_(NULL),
@ -116,6 +138,8 @@ PalfEnvImpl::PalfEnvImpl() : palf_meta_lock_(common::ObLatchIds::PALF_ENV_LOCK),
log_rpc_(),
cb_thread_pool_(),
log_io_worker_(),
block_gc_timer_task_(),
log_updater_(),
disk_options_wrapper_(),
check_disk_print_log_interval_(OB_INVALID_TIMESTAMP),
self_(),
@ -125,6 +149,7 @@ PalfEnvImpl::PalfEnvImpl() : palf_meta_lock_(common::ObLatchIds::PALF_ENV_LOCK),
is_inited_(false)
{
log_dir_[0] = '\0';
tmp_log_dir_[0] = '\0';
}
PalfEnvImpl::~PalfEnvImpl()
@ -133,7 +158,7 @@ PalfEnvImpl::~PalfEnvImpl()
}
int PalfEnvImpl::init(
const PalfDiskOptions &disk_options,
const PalfOptions &options,
const char *base_dir, const ObAddr &self,
rpc::frame::ObReqTransport *transport,
common::ObILogAllocator *log_alloc_mgr,
@ -146,6 +171,7 @@ int PalfEnvImpl::init(
log_io_worker_config_.io_queue_capcity_ = 100 * 1024;
log_io_worker_config_.batch_width_ = 8;
log_io_worker_config_.batch_depth_ = PALF_SLIDING_WINDOW_SIZE;
const int64_t io_cb_num = PALF_SLIDING_WINDOW_SIZE * 128;
if (is_inited_) {
ret = OB_INIT_TWICE;
PALF_LOG(ERROR, "PalfEnvImpl is inited twiced", K(ret));
@ -158,7 +184,7 @@ int PalfEnvImpl::init(
PALF_LOG(ERROR, "FetchLogEngine init failed", K(ret));
} else if (OB_FAIL(log_rpc_.init(self, transport))) {
PALF_LOG(ERROR, "LogRpc init failed", K(ret));
} else if (OB_FAIL(cb_thread_pool_.init(this))) {
} else if (OB_FAIL(cb_thread_pool_.init(io_cb_num, this))) {
PALF_LOG(ERROR, "LogIOTaskThreadPool init failed", K(ret));
} else if (OB_FAIL(log_io_worker_.init(log_io_worker_config_,
cb_thread_pool_.get_tg_id(),
@ -168,11 +194,13 @@ int PalfEnvImpl::init(
PALF_LOG(ERROR, "ObCheckLogBlockCollectTask init failed", K(ret));
} else if ((pret = snprintf(log_dir_, MAX_PATH_SIZE, "%s", base_dir)) && false) {
ret = OB_ERR_UNEXPECTED;
} else if ((pret = snprintf(tmp_log_dir_, MAX_PATH_SIZE, "%s/tmp_dir", log_dir_)) && false) {
ret = OB_ERR_UNEXPECTED;
PALF_LOG(ERROR, "error unexpected", K(ret));
} else if (pret < 0 || pret >= MAX_PATH_SIZE) {
ret = OB_BUF_NOT_ENOUGH;
PALF_LOG(ERROR, "construct log path failed", K(ret), K(pret));
} else if (OB_FAIL(palf_handle_impl_map_.init("LOG_HASH_MAP", MTL_ID()))) {
} else if (OB_FAIL(palf_handle_impl_map_.init("LOG_HASH_MAP", PALF_ENV_ID))) {
PALF_LOG(ERROR, "palf_handle_impl_map_ init failed", K(ret));
} else if (OB_FAIL(log_loop_thread_.init(this))) {
PALF_LOG(ERROR, "log_loop_thread_ init failed", K(ret));
@ -181,8 +209,10 @@ int PalfEnvImpl::init(
PALF_LOG(ERROR, "election_timer_ init failed", K(ret));
} else if (OB_FAIL(election::GLOBAL_INIT_ELECTION_MODULE())) {
PALF_LOG(ERROR, "global init election module failed", K(ret));
} else if (OB_FAIL(disk_options_wrapper_.init(disk_options))) {
} else if (OB_FAIL(disk_options_wrapper_.init(options.disk_options_))) {
PALF_LOG(ERROR, "disk_options_wrapper_ init failed", K(ret));
} else if (OB_FAIL(log_updater_.init(this))) {
PALF_LOG(ERROR, "LogUpdater init failed", K(ret));
} else {
log_alloc_mgr_ = log_alloc_mgr;
log_block_pool_ = log_block_pool;
@ -214,9 +244,11 @@ int PalfEnvImpl::start()
PALF_LOG(ERROR, "FetchLogEngine start failed", K(ret));
} else if (OB_FAIL(log_loop_thread_.start())) {
PALF_LOG(ERROR, "log_loop_thread_ start failed", K(ret));
} else if (OB_FAIL(log_updater_.start())) {
PALF_LOG(ERROR, "LogUpdater start failed", K(ret));
} else {
is_running_ = true;
PALF_LOG(INFO, "PalfEnv start success", K(ret), K(MTL_ID()));
PALF_LOG(INFO, "PalfEnv start success", K(ret), K(PALF_ENV_ID));
}
return ret;
}
@ -231,17 +263,20 @@ void PalfEnvImpl::stop()
block_gc_timer_task_.stop();
fetch_log_engine_.stop();
log_loop_thread_.stop();
log_updater_.stop();
PALF_LOG(INFO, "PalfEnvImpl stop success", KPC(this));
}
}
void PalfEnvImpl::wait()
{
PALF_LOG(INFO, "PalfEnvImpl begin stop", KPC(this));
log_io_worker_.wait();
cb_thread_pool_.wait();
block_gc_timer_task_.wait();
fetch_log_engine_.wait();
log_loop_thread_.wait();
log_updater_.wait();
PALF_LOG(INFO, "PalfEnvImpl wait success", KPC(this));
}
@ -256,89 +291,47 @@ void PalfEnvImpl::destroy()
log_loop_thread_.destroy();
block_gc_timer_task_.destroy();
fetch_log_engine_.destroy();
log_updater_.destroy();
log_rpc_.destroy();
log_alloc_mgr_ = NULL;
self_.reset();
log_dir_[0] = '\0';
tmp_log_dir_[0] = '\0';
disk_options_wrapper_.reset();
}
// NB: not thread safe
int PalfEnvImpl::create_palf_handle_impl(const int64_t palf_id,
const AccessMode &access_mode,
PalfHandleImpl *&palf_handle_impl)
const PalfBaseInfo &palf_base_info,
IPalfHandleImpl *&palf_handle_impl)
{
int ret = OB_SUCCESS;
int pret = 0;
char base_dir[MAX_PATH_SIZE] = {'\0'};
palf_handle_impl = NULL;
LSKey hash_map_key(palf_id);
PalfBaseInfo palf_base_info;
palf_base_info.generate_by_default();
WLockGuard guard(palf_meta_lock_);
const int64_t palf_epoch = ATOMIC_AAF(&last_palf_epoch_, 1);
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
PALF_LOG(WARN, "PalfEnvImpl is not running", K(ret));
} else if (!is_running_) {
ret = OB_NOT_RUNNING;
PALF_LOG(WARN, "PalfEnvImpl is not running", K(ret));
} else if (false == is_valid_palf_id(palf_id)) {
ret = OB_INVALID_ARGUMENT;
PALF_LOG(WARN, "invalid arguments", K(ret), K(palf_id));
} else if (OB_ENTRY_EXIST == palf_handle_impl_map_.contains_key(hash_map_key)) {
ret = OB_ENTRY_EXIST;
PALF_LOG(WARN, "palf_handle has exist, ignore this request", K(ret), K(palf_id));
} else if (false == check_can_create_palf_handle_impl_()) {
ret = OB_LOG_OUTOF_DISK_SPACE;
PALF_LOG(ERROR, "PalfEnv can not hold more instance", K(ret), KPC(this), K(palf_id));
} else if (0 > (pret = snprintf(base_dir, MAX_PATH_SIZE, "%s/%ld", log_dir_, palf_id))) {
ret = OB_ERR_UNEXPECTED;
PALF_LOG(ERROR, "snprinf failed", K(pret), K(palf_id));
} else if (OB_FAIL(create_directory(base_dir))) {
PALF_LOG(WARN, "prepare_directory_for_creating_ls_ failed!!!", K(ret), K(palf_id));
} else if (NULL == (palf_handle_impl = PalfHandleImplFactory::alloc())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
PALF_LOG(WARN, "alloc palf_handle_impl failed", K(ret));
} else if (OB_FAIL(palf_handle_impl->init(palf_id, access_mode, palf_base_info, &fetch_log_engine_, base_dir, log_alloc_mgr_,
log_block_pool_, &log_rpc_, &log_io_worker_, this, self_, &election_timer_, palf_epoch))) {
PALF_LOG(ERROR, "PalfHandleImpl init failed", K(ret), K(palf_id));
// NB: always insert value into hash map finally.
} else if (OB_FAIL(palf_handle_impl_map_.insert_and_get(hash_map_key, palf_handle_impl))) {
PALF_LOG(WARN, "palf_handle_impl_map_ insert_and_get failed", K(ret), K(palf_id));
} else {
// TODO: 直接推进状态让leader自动上任
palf_handle_impl->set_scan_disk_log_finished();
}
if (OB_FAIL(ret) && NULL != palf_handle_impl) {
// if 'palf_handle_impl' has not been inserted into hash map,
// need reclaim manually.
PalfHandleImplFactory::free(palf_handle_impl);
PALF_LOG(WARN, "PalfEnvImpl is not inited", K(ret));
} else if (OB_FAIL(create_palf_handle_impl_(palf_id, access_mode, palf_base_info,
NORMAL_REPLICA, palf_handle_impl))) {
palf_handle_impl = NULL;
if (OB_ENTRY_NOT_EXIST == palf_handle_impl_map_.contains_key(hash_map_key)) {
remove_directory(base_dir);
}
} else {
PALF_LOG(INFO, "PalfEnvImpl create_palf_handle_impl finished", K(ret), K(palf_id), K(access_mode),
K(palf_base_info), KPC(this));
}
PALF_LOG(INFO, "PalfEnvImpl create_palf_handle_impl finished", K(ret), K(palf_id), KPC(this));
return ret;
}
// 迁移目的端副本创建接口
// NB: not thread safe
int PalfEnvImpl::create_palf_handle_impl(const int64_t palf_id,
const AccessMode &access_mode,
const PalfBaseInfo &palf_base_info,
PalfHandleImpl *&palf_handle_impl)
int PalfEnvImpl::create_palf_handle_impl_(const int64_t palf_id,
const AccessMode &access_mode,
const PalfBaseInfo &palf_base_info,
const LogReplicaType replica_type,
IPalfHandleImpl *&ipalf_handle_impl)
{
int ret = OB_SUCCESS;
int pret = 0;
char base_dir[MAX_PATH_SIZE] = {'\0'};
palf_handle_impl = NULL;
PalfHandleImpl *palf_handle_impl = NULL;
LSKey hash_map_key(palf_id);
WLockGuard guard(palf_meta_lock_);
const int64_t palf_epoch = ATOMIC_AAF(&last_palf_epoch_, 1);
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
@ -363,14 +356,16 @@ int PalfEnvImpl::create_palf_handle_impl(const int64_t palf_id,
} else if (NULL == (palf_handle_impl = PalfHandleImplFactory::alloc())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
PALF_LOG(WARN, "alloc palf_handle_impl failed", K(ret));
} else if (OB_FAIL(palf_handle_impl->init(palf_id, access_mode, palf_base_info, &fetch_log_engine_, base_dir, log_alloc_mgr_,
log_block_pool_, &log_rpc_, &log_io_worker_, this, self_, &election_timer_, palf_epoch))) {
PALF_LOG(ERROR, "PalfHandleImpl init failed", K(ret), K(palf_id));
} else if (OB_FAIL(palf_handle_impl->init(palf_id, access_mode, palf_base_info, replica_type,
&fetch_log_engine_, base_dir, log_alloc_mgr_, log_block_pool_, &log_rpc_, &log_io_worker_,
this, self_, &election_timer_, palf_epoch))) {
PALF_LOG(ERROR, "IPalfHandleImpl init failed", K(ret), K(palf_id));
// NB: always insert value into hash map finally.
} else if (OB_FAIL(palf_handle_impl_map_.insert_and_get(hash_map_key, palf_handle_impl))) {
PALF_LOG(WARN, "palf_handle_impl_map_ insert_and_get failed", K(ret), K(palf_id));
} else {
palf_handle_impl->set_scan_disk_log_finished();
ipalf_handle_impl = palf_handle_impl;
}
if (OB_FAIL(ret) && NULL != palf_handle_impl) {
@ -383,7 +378,8 @@ int PalfEnvImpl::create_palf_handle_impl(const int64_t palf_id,
}
}
PALF_LOG(INFO, "PalfEnvImpl create_palf_handle_impl finished", K(ret), K(palf_id), KPC(this));
PALF_LOG(INFO, "PalfEnvImpl create_palf_handle_impl_ finished", K(ret), K(palf_id),
K(access_mode), K(palf_base_info), K(replica_type), KPC(this));
return ret;
}
@ -391,23 +387,15 @@ int PalfEnvImpl::create_palf_handle_impl(const int64_t palf_id,
int PalfEnvImpl::remove_palf_handle_impl(const int64_t palf_id)
{
int ret = OB_SUCCESS;
LSKey hash_map_key(palf_id);
auto set_delete_func = [](const LSKey &key, PalfHandleImpl *value) {
UNUSED(key);
value->set_deleted();
};
WLockGuard guard(palf_meta_lock_);
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
PALF_LOG(ERROR, "PalfEnvImpl is not inited", K(ret));
} else if (OB_FAIL(palf_handle_impl_map_.operate(hash_map_key, set_delete_func))) {
PALF_LOG(WARN, "operate palf_handle_impl_map_ failed", K(ret), K(palf_id), KPC(this));
} else if (OB_FAIL(palf_handle_impl_map_.del(hash_map_key))) {
PALF_LOG(WARN, "palf_handle_impl_map_ del failed", K(ret), K(palf_id));
} else if (OB_FAIL(remove_palf_handle_impl_from_map_not_guarded_by_lock_(palf_id))) {
PALF_LOG(WARN, "palf instance not exist", K(ret), KPC(this), K(palf_id));
} else if (OB_FAIL(wait_until_reference_count_to_zero_(palf_id))) {
PALF_LOG(WARN, "wait_until_reference_count_to_zero_ failed", K(ret), K(palf_id), KPC(this));
PALF_LOG(WARN, "wait_until_reference_count_to_zero_ failed", K(ret), KPC(this), K(palf_id));
} else {
PALF_LOG(INFO, "remove_palf_handle_impl success", K(ret), K(palf_id));
}
if (OB_ENTRY_NOT_EXIST == ret) {
ret = OB_SUCCESS;
@ -416,29 +404,28 @@ int PalfEnvImpl::remove_palf_handle_impl(const int64_t palf_id)
}
int PalfEnvImpl::get_palf_handle_impl(const int64_t palf_id,
PalfHandleImplGuard &palf_handle_impl_guard)
IPalfHandleImplGuard &palf_handle_impl_guard)
{
int ret = OB_SUCCESS;
PalfHandleImpl *palf_handle_impl = NULL;
IPalfHandleImpl *palf_handle_impl = NULL;
if (OB_FAIL(get_palf_handle_impl(palf_id, palf_handle_impl))) {
PALF_LOG(TRACE, "get_palf_handle_impl failed", K(ret), K(palf_id), K(palf_handle_impl));
} else if (OB_FAIL(palf_handle_impl_guard.set_palf_handle_impl(palf_id,
palf_handle_impl,
&palf_handle_impl_map_))) {
PALF_LOG(WARN, "PalfHandleImplGuard set_palf_handle_impl failed", K(ret),
K(palf_id), K(palf_handle_impl));
revert_palf_handle_impl(palf_handle_impl);
PALF_LOG(TRACE, "get_palf_handle_impl failed", K(ret), K(palf_id));
} else {
palf_handle_impl_guard.palf_env_impl_ = this;
palf_handle_impl_guard.palf_handle_impl_ = palf_handle_impl;
palf_handle_impl_guard.palf_id_ = palf_id;
PALF_LOG(TRACE, "get_palf_handle_impl success", K(palf_id), K(palf_handle_impl_guard));
// do nothing
}
return ret;
}
int PalfEnvImpl::get_palf_handle_impl(const int64_t palf_id,
PalfHandleImpl *&palf_handle_impl)
IPalfHandleImpl *&ipalf_handle_impl)
{
int ret = OB_SUCCESS;
LSKey hash_map_key(palf_id);
IPalfHandleImpl *palf_handle_impl = NULL;
if (false == is_valid_palf_id(palf_id)) {
ret = OB_INVALID_ARGUMENT;
PALF_LOG(ERROR, "Invalid argument!!!", K(ret), K(palf_id));
@ -447,19 +434,19 @@ int PalfEnvImpl::get_palf_handle_impl(const int64_t palf_id,
} else if (false == palf_handle_impl->check_can_be_used()) {
ret = OB_ENTRY_NOT_EXIST;
} else {
PALF_LOG(TRACE, "PalfEnvImpl get_palf_handle_impl success", K(palf_id), K(self_), KP(palf_handle_impl));
ipalf_handle_impl = palf_handle_impl;
}
if (OB_FAIL(ret)) {
if (OB_FAIL(ret) && NULL != palf_handle_impl) {
revert_palf_handle_impl(palf_handle_impl);
}
return ret;
}
void PalfEnvImpl::revert_palf_handle_impl(PalfHandleImpl *palf_handle_impl)
void PalfEnvImpl::revert_palf_handle_impl(IPalfHandleImpl *ipalf_handle_impl)
{
if (NULL != palf_handle_impl) {
palf_handle_impl_map_.revert(palf_handle_impl);
if (NULL != ipalf_handle_impl) {
palf_handle_impl_map_.revert(ipalf_handle_impl);
}
}
@ -496,13 +483,13 @@ int PalfEnvImpl::create_directory(const char *base_dir)
ret = OB_ERR_UNEXPECTED;
PALF_LOG(ERROR, "snprinf failed", K(pret), K(base_dir));
} else if (-1 == (::mkdir(tmp_base_dir, mode))) {
ret = EEXIST == errno ? OB_FILE_OR_DIRECTORY_EXIST : OB_IO_ERROR;
ret = convert_sys_errno();
PALF_LOG(WARN, "mkdir failed", K(ret), K(errno), K(tmp_base_dir), K(base_dir));
} else if (-1 == (::mkdir(log_dir, mode))) {
ret = EEXIST == errno ? OB_FILE_OR_DIRECTORY_EXIST : OB_IO_ERROR;
ret = convert_sys_errno();
PALF_LOG(WARN, "mkdir failed", K(ret), K(errno), K(tmp_base_dir), K(base_dir));
} else if (-1 == (::mkdir(meta_dir, mode))) {
ret = EEXIST == errno ? OB_FILE_OR_DIRECTORY_EXIST : OB_IO_ERROR;
ret = convert_sys_errno();
PALF_LOG(WARN, "mkdir failed", K(ret), K(errno), K(tmp_base_dir), K(base_dir));
} else if (-1 == (::rename(tmp_base_dir, base_dir))) {
ret = OB_ERR_UNEXPECTED;
@ -541,78 +528,6 @@ int PalfEnvImpl::remove_directory(const char *log_dir)
return ret;
}
bool PalfEnvImpl::SwitchStateFunctor::operator() (const LSKey &palf_id, PalfHandleImpl *palf_handle_impl)
{
int tmp_ret = OB_SUCCESS;
if (NULL == palf_handle_impl) {
PALF_LOG(ERROR, "palf_handle_impl is NULL", KP(palf_handle_impl), K(palf_id));
} else if (OB_SUCCESS != (tmp_ret = palf_handle_impl->check_and_switch_state())) {
PALF_LOG(WARN, "check_and_switch_state failed", K(tmp_ret), K(palf_id));
} else {}
return true;
}
bool PalfEnvImpl::FreezeLogFunctor::operator() (const LSKey &palf_id, PalfHandleImpl *palf_handle_impl)
{
int tmp_ret = OB_SUCCESS;
if (NULL == palf_handle_impl) {
PALF_LOG(ERROR, "palf_handle_impl is NULL", KP(palf_handle_impl), K(palf_id));
} else if (OB_SUCCESS != (tmp_ret = palf_handle_impl->period_freeze_last_log())) {
PALF_LOG(WARN, "period_freeze_last_log failed", K(tmp_ret), K(palf_id));
} else {}
return true;
}
bool PalfEnvImpl::CheckFreezeModeFunctor::operator() (const LSKey &palf_id, PalfHandleImpl *palf_handle_impl)
{
int tmp_ret = OB_SUCCESS;
if (NULL == palf_handle_impl) {
PALF_LOG(ERROR, "palf_handle_impl is NULL", KP(palf_handle_impl), K(palf_id));
} else if (OB_SUCCESS != (tmp_ret = palf_handle_impl->check_and_switch_freeze_mode())) {
PALF_LOG(WARN, "check_and_switch_freeze_mode failed", K(tmp_ret), K(palf_id));
} else {}
return true;
}
int PalfEnvImpl::try_switch_state_for_all()
{
int ret = OB_SUCCESS;
SwitchStateFunctor switch_state_functor;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
PALF_LOG(WARN, "PalfEnvImpl is not inited", K(ret));
} else if (OB_FAIL(palf_handle_impl_map_.for_each(switch_state_functor))) {
PALF_LOG(WARN, "palf_handle_impl_map_ for_each failed", K(ret));
} else {}
return ret;
}
int PalfEnvImpl::check_and_switch_freeze_mode()
{
int ret = OB_SUCCESS;
CheckFreezeModeFunctor check_freeze_mode_functor;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
PALF_LOG(WARN, "PalfEnvImpl is not inited", K(ret));
} else if (OB_FAIL(palf_handle_impl_map_.for_each(check_freeze_mode_functor))) {
PALF_LOG(WARN, "palf_handle_impl_map_ for_each failed", K(ret));
} else {}
return ret;
}
int PalfEnvImpl::try_freeze_log_for_all()
{
int ret = OB_SUCCESS;
FreezeLogFunctor freeze_functor;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
PALF_LOG(WARN, "PalfEnvImpl is not inited", K(ret));
} else if (OB_FAIL(palf_handle_impl_map_.for_each(freeze_functor))) {
PALF_LOG(WARN, "palf_handle_impl_map_ for_each failed", K(ret));
} else {}
return ret;
}
PalfEnvImpl::LogGetRecycableFileCandidate::LogGetRecycableFileCandidate()
: id_(-1),
min_block_id_(LOG_INVALID_BLOCK_ID),
@ -634,7 +549,7 @@ PalfEnvImpl::LogGetRecycableFileCandidate::~LogGetRecycableFileCandidate()
id_ = -1;
}
bool PalfEnvImpl::LogGetRecycableFileCandidate::operator()(const LSKey &palf_id, PalfHandleImpl *palf_handle_impl)
bool PalfEnvImpl::LogGetRecycableFileCandidate::operator()(const LSKey &palf_id, IPalfHandleImpl *palf_handle_impl)
{
bool bool_ret = true;
if (NULL == palf_handle_impl) {
@ -659,7 +574,7 @@ bool PalfEnvImpl::LogGetRecycableFileCandidate::operator()(const LSKey &palf_id,
&& !need_skip_by_ret(ret)) {
ret_code_ = ret;
bool_ret = false;
PALF_LOG(WARN, "LogGetRecycableFileCandidate get_min_block_id_min_scn failed", K(ret), K(palf_id));
PALF_LOG(WARN, "LogGetRecycableFileCandidate get_min_block_info_for_gc failed", K(ret), K(palf_id));
// recycable conditions:
// 1. current palf_handle_impl must have some block can be recycable;
// 2. current palf_handle_impl must have older blocks(at least two blocks).
@ -765,6 +680,8 @@ int PalfEnvImpl::try_recycle_blocks()
"oldest_log_stream", oldest_palf_id,
"oldest_scn", oldest_scn);
}
(void)remove_stale_incomplete_palf_();
}
return ret;
}
@ -774,22 +691,11 @@ bool PalfEnvImpl::check_disk_space_enough()
return true == ATOMIC_LOAD(&diskspace_enough_);
}
// TODO by yunlong
bool PalfEnvImpl::check_tenant_memory_enough()
{
bool bool_ret = false;
if (IS_NOT_INIT) {
} else {
bool_ret = true;
}
return bool_ret;
}
PalfEnvImpl::GetTotalUsedDiskSpace::GetTotalUsedDiskSpace()
: total_used_disk_space_(0), maximum_used_size_(0), palf_id_(INVALID_PALF_ID) {}
PalfEnvImpl::GetTotalUsedDiskSpace::~GetTotalUsedDiskSpace() {}
bool PalfEnvImpl::GetTotalUsedDiskSpace::operator() (const LSKey &ls_key, PalfHandleImpl *palf_handle_impl)
bool PalfEnvImpl::GetTotalUsedDiskSpace::operator() (const LSKey &ls_key, IPalfHandleImpl *palf_handle_impl)
{
bool bool_ret = true;
if (NULL == palf_handle_impl) {
@ -808,6 +714,50 @@ bool PalfEnvImpl::GetTotalUsedDiskSpace::operator() (const LSKey &ls_key, PalfHa
return bool_ret;
}
PalfEnvImpl::RemoveStaleIncompletePalfFunctor::RemoveStaleIncompletePalfFunctor(PalfEnvImpl *palf_env_impl)
: palf_env_impl_(palf_env_impl)
{}
PalfEnvImpl::RemoveStaleIncompletePalfFunctor::~RemoveStaleIncompletePalfFunctor()
{
palf_env_impl_ = NULL;
}
int PalfEnvImpl::RemoveStaleIncompletePalfFunctor::func(const dirent *entry)
{
int ret = OB_SUCCESS;
char file_name[OB_MAX_FILE_NAME_LENGTH] = {'\0'};
const char *d_name = entry->d_name;
MEMCPY(file_name, d_name, strlen(d_name));
char *tmp = strtok(file_name, "_");
char *timestamp_str = NULL;
if (NULL == tmp || NULL == (timestamp_str = strtok(NULL, "_"))) {
ret = OB_ERR_UNEXPECTED;
PALF_LOG(WARN, "unexpected format", K(ret), K(tmp), K(file_name));
} else {
int64_t timestamp = atol(timestamp_str);
int64_t current_timestamp = ObTimeUtility::current_time();
int64_t delta = current_timestamp - timestamp;
constexpr int64_t week_us = 7 * 24 * 60 * 60 * 1000 * 1000ll;
if (delta <= week_us) {
PALF_LOG(TRACE, "no need remove this incomplet dir", K(d_name), K(delta),
K(timestamp), K(timestamp_str), K(current_timestamp));
} else {
char path[OB_MAX_FILE_NAME_LENGTH] = {'\0'};
int pret = OB_SUCCESS;
if (0 > (pret = snprintf(path, MAX_PATH_SIZE, "%s/%s", palf_env_impl_->tmp_log_dir_, d_name))) {
ret = OB_ERR_UNEXPECTED;
PALF_LOG(WARN, "snprintf failed", K(ret), K(file_name), K(d_name));
} else if (OB_FAIL(FileDirectoryUtils::delete_directory_rec(path))) {
PALF_LOG(WARN, "delete_directory_rec failed", K(ret), K(file_name), K(path), K(entry->d_name), K(timestamp_str));
} else {
PALF_LOG(WARN, "current incomplete palf has bee staled, delete it", K(timestamp), K(current_timestamp), K(path));
}
}
}
return ret;
}
int PalfEnvImpl::get_disk_usage(int64_t &used_size_byte, int64_t &total_usable_size_byte)
{
int ret = OB_SUCCESS;
@ -822,41 +772,66 @@ int PalfEnvImpl::get_disk_usage(int64_t &used_size_byte, int64_t &total_usable_s
return ret;
}
int PalfEnvImpl::update_disk_options(const PalfDiskOptions &disk_options)
int PalfEnvImpl::update_options(const PalfOptions &options)
{
int ret = OB_SUCCESS;
WLockGuard guard(palf_meta_lock_);
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
} else if (false == disk_options.is_valid()) {
} else if (false == options.is_valid()) {
ret = OB_INVALID_ARGUMENT;
PALF_LOG(WARN, "invalid argument", K(disk_options));
} else if (OB_FAIL(disk_options_wrapper_.update_disk_options(disk_options))) {
PALF_LOG(WARN, "update_disk_options failed", K(ret));
PALF_LOG(WARN, "invalid argument", K(options));
} else if (OB_FAIL(disk_options_wrapper_.update_disk_options(options.disk_options_))) {
PALF_LOG(WARN, "update_disk_options failed", K(ret), K(options));
} else if (OB_FAIL(log_rpc_.update_transport_compress_options(options.compress_options_))) {
PALF_LOG(WARN, "update_transport_compress_options failed", K(ret), K(options));
} else {
PALF_LOG(INFO, "update_disk_options success", K(disk_options_wrapper_));
PALF_LOG(INFO, "update_palf_options success", K(options));
}
return ret;
}
int PalfEnvImpl::get_disk_options(PalfDiskOptions &disk_options)
int PalfEnvImpl::get_options(PalfOptions &options)
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
} else {
disk_options = disk_options_wrapper_.get_disk_opts_for_recycling_blocks();
options.disk_options_ = disk_options_wrapper_.get_disk_opts_for_recycling_blocks();
options.compress_options_ = log_rpc_.get_compress_opts();
}
return ret;
}
int PalfEnvImpl::for_each(const common::ObFunction<int (IPalfHandleImpl *)> &func)
{
auto func_impl = [&func](const LSKey &ls_key, IPalfHandleImpl *ipalf_handle_impl) -> bool {
bool bool_ret = true;
int ret = OB_SUCCESS;
if (OB_FAIL(func(ipalf_handle_impl))) {
PALF_LOG(WARN, "execute func failed", K(ret), K(ls_key));
} else {
}
if (OB_FAIL(ret)) {
bool_ret = false;
}
return bool_ret;
};
int ret = OB_SUCCESS;
if (OB_FAIL(palf_handle_impl_map_.for_each(func_impl))) {
PALF_LOG(WARN, "iterate palf_handle_impl_map_ failed", K(ret));
} else {
}
return ret;
}
int PalfEnvImpl::for_each(const common::ObFunction<int (const PalfHandle &)> &func)
{
auto func_impl = [&func](const LSKey &ls_key, PalfHandleImpl *palf_handle_impl) -> bool {
auto func_impl = [&func](const LSKey &ls_key, IPalfHandleImpl *ipalf_handle_impl) -> bool {
bool bool_ret = true;
int ret = OB_SUCCESS;
PalfHandle palf_handle;
palf_handle.palf_handle_impl_ = palf_handle_impl;
palf_handle.palf_handle_impl_ = ipalf_handle_impl;
if (OB_FAIL(func(palf_handle))) {
PALF_LOG(WARN, "execute func failed", K(ret), K(ls_key));
} else {
@ -933,15 +908,16 @@ int PalfEnvImpl::reload_palf_handle_impl_(const int64_t palf_id)
char base_dir[OB_MAX_FILE_NAME_LENGTH] = {'\0'};
int64_t start_ts = ObTimeUtility::current_time();
LSKey hash_map_key(palf_id);
bool is_integrity = true;
const int64_t palf_epoch = ATOMIC_AAF(&last_palf_epoch_, 1);
if (0 > (pret = snprintf(base_dir, MAX_PATH_SIZE, "%s/%ld", log_dir_, palf_id))) {
ret = OB_ERR_UNEXPECTED;
PALF_LOG(WARN, "snprint failed", K(ret), K(pret), K(palf_id));
} else if (NULL == (tmp_palf_handle_impl = PalfHandleImplFactory::alloc())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
PALF_LOG(WARN, "alloc palf_handle_impl failed", K(ret));
PALF_LOG(WARN, "alloc ipalf_handle_impl failed", K(ret));
} else if (OB_FAIL(tmp_palf_handle_impl->load(palf_id, &fetch_log_engine_, base_dir, log_alloc_mgr_,
log_block_pool_, &log_rpc_, &log_io_worker_, this, self_, &election_timer_, palf_epoch))) {
log_block_pool_, &log_rpc_, &log_io_worker_, this, self_, &election_timer_, palf_epoch, is_integrity))) {
PALF_LOG(ERROR, "PalfHandleImpl init failed", K(ret), K(palf_id));
} else if (OB_FAIL(palf_handle_impl_map_.insert_and_get(hash_map_key, tmp_palf_handle_impl))) {
PALF_LOG(WARN, "palf_handle_impl_map_ insert_and_get failed", K(ret), K(palf_id), K(tmp_palf_handle_impl));
@ -949,7 +925,8 @@ int PalfEnvImpl::reload_palf_handle_impl_(const int64_t palf_id)
(void) tmp_palf_handle_impl->set_scan_disk_log_finished();
palf_handle_impl_map_.revert(tmp_palf_handle_impl);
int64_t cost_ts = ObTimeUtility::current_time() - start_ts;
PALF_LOG(INFO, "reload_palf_handle_impl success", K(ret), K(palf_id), K(cost_ts), KP(this), KP(&palf_handle_impl_map_));
PALF_LOG(INFO, "reload_palf_handle_impl success", K(ret), K(palf_id), K(cost_ts), KP(this),
KP(&palf_handle_impl_map_));
}
if (OB_FAIL(ret) && NULL != tmp_palf_handle_impl) {
@ -960,6 +937,9 @@ int PalfEnvImpl::reload_palf_handle_impl_(const int64_t palf_id)
PalfHandleImplFactory::free(tmp_palf_handle_impl);
tmp_palf_handle_impl = NULL;
}
} else if (false == is_integrity) {
PALF_LOG(WARN, "palf instance is not integrity, remove it", K(palf_id));
ret = move_incomplete_palf_into_tmp_dir_(palf_id);
}
return ret;
}
@ -1017,7 +997,7 @@ int PalfEnvImpl::recycle_blocks_(bool &has_recycled, int64_t &oldest_palf_id, SC
if (OB_FAIL(palf_handle_impl_map_.for_each(functor))) {
PALF_LOG(WARN, "palf_handle_impl_map_ for_each failed", K(ret), K(functor));
} else {
PalfHandleImplGuard guard;
IPalfHandleImplGuard guard;
int64_t palf_id(functor.id_);
const block_id_t min_block_id = functor.min_block_id_;
if (false == is_valid_block_id(min_block_id)) {
@ -1070,5 +1050,93 @@ bool PalfEnvImpl::check_can_create_palf_handle_impl_() const
bool_ret = (count + 1) * MIN_DISK_SIZE_PER_PALF_INSTANCE <= disk_opts.log_disk_usage_limit_size_;
return bool_ret;
}
int PalfEnvImpl::remove_palf_handle_impl_from_map_not_guarded_by_lock_(const int64_t palf_id)
{
int ret = OB_SUCCESS;
LSKey hash_map_key(palf_id);
auto set_delete_func = [](const LSKey &key, IPalfHandleImpl *value) {
UNUSED(key);
value->set_deleted();
};
if (OB_FAIL(palf_handle_impl_map_.operate(hash_map_key, set_delete_func))) {
PALF_LOG(WARN, "operate palf_handle_impl_map_ failed", K(ret), K(palf_id), KPC(this));
} else if (OB_FAIL(palf_handle_impl_map_.del(hash_map_key))) {
PALF_LOG(WARN, "palf_handle_impl_map_ del failed", K(ret), K(palf_id));
} else {
PALF_LOG(INFO, "remove_palf_handle_impl success", K(ret), K(palf_id));
}
return ret;
}
int PalfEnvImpl::move_incomplete_palf_into_tmp_dir_(const int64_t palf_id)
{
int ret = OB_SUCCESS;
int pret = 0;
const mode_t mode = S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH;
char src_log_dir[OB_MAX_FILE_NAME_LENGTH] = {'\0'};
char dest_log_dir[OB_MAX_FILE_NAME_LENGTH] = {'\0'};
bool tmp_dir_exist = false;
LSKey hash_map_key(palf_id);
int64_t timestamp = ObTimeUtility::current_time();
if (OB_FAIL(palf_handle_impl_map_.del(hash_map_key))) {
PALF_LOG(WARN, "del palf from map failed, unexpected", K(ret),
K(palf_id), KPC(this));;
} else if (OB_FAIL(check_tmp_log_dir_exist_(tmp_dir_exist))) {
} else if (false == tmp_dir_exist && (-1 == ::mkdir(tmp_log_dir_, mode))) {
ret = convert_sys_errno();
PALF_LOG(ERROR, "mkdir tmp log dir failed", K(ret), KPC(this), K(tmp_log_dir_));
} else if (0 > (pret = snprintf(src_log_dir, MAX_PATH_SIZE, "%s/%ld", log_dir_, palf_id))) {
ret = OB_ERR_UNEXPECTED;
PALF_LOG(ERROR, "snprintf failed, unexpected error", K(ret));
} else if (0 > (pret = snprintf(dest_log_dir, MAX_PATH_SIZE, "%s/%ld_%ld", tmp_log_dir_, palf_id, timestamp))) {
ret = OB_ERR_UNEXPECTED;
PALF_LOG(ERROR, "snprintf failed, unexpected error", K(ret));
} else if (-1 == ::rename(src_log_dir, dest_log_dir)) {
ret = convert_sys_errno();
PALF_LOG(ERROR, "::rename failed", K(ret), KPC(this), K(src_log_dir), K(dest_log_dir));
} else if (OB_FAIL(FileDirectoryUtils::fsync_dir(log_dir_))) {
PALF_LOG(ERROR, "fsync_dir failed", K(ret), KPC(this), K(src_log_dir), K(dest_log_dir));
} else {
}
return ret;
}
int PalfEnvImpl::check_tmp_log_dir_exist_(bool &exist) const
{
int ret = OB_SUCCESS;
if (OB_FAIL(FileDirectoryUtils::is_exists(tmp_log_dir_, exist))) {
PALF_LOG(WARN, "check dir exist failed", K(ret), KPC(this), K(tmp_log_dir_));
} else {
}
return ret;
}
int PalfEnvImpl::remove_stale_incomplete_palf_()
{
int ret = OB_SUCCESS;
bool exist = false;
RemoveStaleIncompletePalfFunctor functor(this);
if (OB_FAIL(check_tmp_log_dir_exist_(exist))) {
PALF_LOG(WARN, "check_tmp_log_dir_exist_ failed", K(ret), KPC(this));
} else if (false == exist) {
} else if (OB_FAIL(scan_dir(tmp_log_dir_, functor))){
PALF_LOG(WARN, "remove_stale_incomplete_palf_ failed", K(ret), KPC(this), K(tmp_log_dir_));
} else {
}
return ret;
}
int PalfEnvImpl::get_io_start_time(int64_t &last_working_time)
{
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = OB_NOT_INIT;
} else {
last_working_time = log_io_worker_.get_last_working_time();
}
return ret;
}
} // end namespace palf
} // end namespace oceanbase