init push
This commit is contained in:
oceanbase-admin
274
src/archive/ob_archive_block.cpp
Normal file
274
src/archive/ob_archive_block.cpp
Normal file
@ -0,0 +1,274 @@
|
||||
/**
|
||||
* Copyright (c) 2021 OceanBase
|
||||
* OceanBase CE is licensed under Mulan PubL v2.
|
||||
* You can use this software according to the terms and conditions of the Mulan PubL v2.
|
||||
* You may obtain a copy of Mulan PubL v2 at:
|
||||
* http://license.coscl.org.cn/MulanPubL-2.0
|
||||
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
|
||||
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
||||
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
||||
* See the Mulan PubL v2 for more details.
|
||||
*/
|
||||
|
||||
#include "ob_archive_block.h"
|
||||
|
||||
#include "common/ob_clock_generator.h"
|
||||
#include "share/ob_define.h"
|
||||
#include "lib/checksum/ob_crc64.h"
|
||||
#include "lib/utility/utility.h"
|
||||
#include "lib/utility/serialization.h"
|
||||
|
||||
namespace oceanbase {
|
||||
|
||||
using namespace common;
|
||||
namespace archive {
|
||||
ObArchiveBlockMeta::ObArchiveBlockMeta()
|
||||
{
|
||||
reset();
|
||||
}
|
||||
|
||||
ObArchiveBlockMeta::~ObArchiveBlockMeta()
|
||||
{
|
||||
reset();
|
||||
}
|
||||
|
||||
int ObArchiveBlockMeta::generate_block_(const char* buf, const int64_t data_len)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
int64_t meta_len = get_serialize_size();
|
||||
int64_t total_len = data_len + meta_len;
|
||||
|
||||
magic_ = META_MAGIC;
|
||||
version_ = ARCHIVE_BLOCK_VERSION;
|
||||
total_len_ = total_len;
|
||||
timestamp_ = ObClockGenerator::getClock();
|
||||
data_checksum_ = calc_data_checksum_(buf, data_len);
|
||||
meta_checksum_ = calc_meta_checksum_();
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void ObArchiveBlockMeta::reset()
|
||||
{
|
||||
magic_ = META_MAGIC;
|
||||
version_ = ARCHIVE_BLOCK_VERSION;
|
||||
total_len_ = 0;
|
||||
timestamp_ = OB_INVALID_TIMESTAMP;
|
||||
|
||||
clog_epoch_id_ = OB_INVALID_TIMESTAMP;
|
||||
accum_checksum_ = 0;
|
||||
min_log_id_in_file_ = OB_INVALID_ID;
|
||||
min_log_ts_in_file_ = OB_INVALID_TIMESTAMP;
|
||||
max_log_id_ = OB_INVALID_ID;
|
||||
max_checkpoint_ts_ = OB_INVALID_TIMESTAMP;
|
||||
max_log_submit_ts_ = OB_INVALID_TIMESTAMP;
|
||||
|
||||
input_bytes_ = 0;
|
||||
output_bytes_ = 0;
|
||||
|
||||
data_checksum_ = 0;
|
||||
meta_checksum_ = 0;
|
||||
}
|
||||
|
||||
bool ObArchiveBlockMeta::check_integrity(const char* data_buf, const int64_t data_len) const
|
||||
{
|
||||
bool bool_ret = true;
|
||||
int16_t magic = META_MAGIC;
|
||||
if (magic != magic_) {
|
||||
bool_ret = false;
|
||||
ARCHIVE_LOG(WARN, "magic is different", "magic", magic_, "expected", magic);
|
||||
} else if (!check_meta_checksum()) {
|
||||
bool_ret = false;
|
||||
ARCHIVE_LOG(WARN, "check meta checksum fails", "meta", to_cstring(*this));
|
||||
} else if (!check_data_checksum_(data_buf, data_len)) {
|
||||
bool_ret = false;
|
||||
ARCHIVE_LOG(WARN, "check data checksum fails");
|
||||
} else {
|
||||
// do nothing
|
||||
}
|
||||
return bool_ret;
|
||||
}
|
||||
|
||||
bool ObArchiveBlockMeta::check_data_checksum_(const char* buf, const int64_t data_len) const
|
||||
{
|
||||
bool bool_ret = true;
|
||||
int64_t ori_data_len = get_data_len();
|
||||
|
||||
// we do not allow null buf here
|
||||
if (NULL == buf || data_len <= 0) {
|
||||
bool_ret = false;
|
||||
ARCHIVE_LOG(WARN, "buf is null", K(data_len), K(*this));
|
||||
} else if (data_len == ori_data_len) {
|
||||
int64_t crc_check_sum = ob_crc64(buf, data_len);
|
||||
if (crc_check_sum == data_checksum_) {
|
||||
// checksum pass
|
||||
} else {
|
||||
bool_ret = false;
|
||||
ARCHIVE_LOG(ERROR, "checksum is not consistent", KP(buf), K(data_len), K(crc_check_sum), K(data_checksum_));
|
||||
}
|
||||
} else {
|
||||
bool_ret = false;
|
||||
ARCHIVE_LOG(ERROR, "data_len is not the same", KP(buf), K(data_len), K(ori_data_len), K(data_checksum_));
|
||||
}
|
||||
return bool_ret;
|
||||
}
|
||||
|
||||
bool ObArchiveBlockMeta::check_meta_checksum() const
|
||||
{
|
||||
bool bool_ret = true;
|
||||
int64_t calc_checksum = calc_meta_checksum_();
|
||||
if (meta_checksum_ != calc_checksum) {
|
||||
bool_ret = false;
|
||||
ARCHIVE_LOG(WARN, "failed to checkmeta checksum ", K(calc_checksum), K(meta_checksum_));
|
||||
}
|
||||
return bool_ret;
|
||||
}
|
||||
|
||||
int64_t ObArchiveBlockMeta::calc_data_checksum_(const char* buf, const int64_t data_len) const
|
||||
{
|
||||
int64_t checksum = 0;
|
||||
if ((NULL == buf) && (data_len == 0)) {
|
||||
// correct situation, checksum = 0 is expected
|
||||
} else if ((NULL != buf) && (data_len > 0)) {
|
||||
checksum = ob_crc64(buf, data_len);
|
||||
} else {
|
||||
// wrong situations, checksum = 0 is default
|
||||
ARCHIVE_LOG(ERROR, "data checksum", "buf", buf, "data_len", data_len);
|
||||
}
|
||||
return checksum;
|
||||
}
|
||||
|
||||
int64_t ObArchiveBlockMeta::calc_meta_checksum_() const
|
||||
{
|
||||
int64_t checksum = 0;
|
||||
// excludes meta_checksum_, the calculation relies on the structure of the meta
|
||||
int64_t calc_checksum_len = sizeof(*this) - sizeof(meta_checksum_);
|
||||
checksum = ob_crc64(this, calc_checksum_len);
|
||||
return checksum;
|
||||
}
|
||||
|
||||
int ObArchiveBlockMeta::serialize(char* buf, const int64_t buf_len, int64_t& pos) const
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
int64_t new_pos = pos;
|
||||
if ((NULL == buf) || (buf_len <= 0)) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
ARCHIVE_LOG(WARN, "invalid argument", KR(ret), KP(buf), K(buf_len));
|
||||
} else if (OB_FAIL(serialization::encode_i16(buf, buf_len, new_pos, magic_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize magic_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::encode_i16(buf, buf_len, new_pos, version_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize version_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::encode_i32(buf, buf_len, new_pos, total_len_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize total_len_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::encode_i64(buf, buf_len, new_pos, timestamp_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize timestamp_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::encode_i64(buf, buf_len, new_pos, clog_epoch_id_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize clog_epoch_id_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::encode_i64(buf, buf_len, new_pos, accum_checksum_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize accum_checksum_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::encode_i64(buf, buf_len, new_pos, min_log_id_in_file_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize min_log_id_in_file_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::encode_i64(buf, buf_len, new_pos, min_log_ts_in_file_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize min_log_ts_in_file_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::encode_i64(buf, buf_len, new_pos, max_log_id_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize max_log_id_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::encode_i64(buf, buf_len, new_pos, max_checkpoint_ts_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize max_checkpoint_ts_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::encode_i64(buf, buf_len, new_pos, max_log_submit_ts_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize max_log_submit_ts_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::encode_i64(buf, buf_len, new_pos, input_bytes_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize input_bytes_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::encode_i64(buf, buf_len, new_pos, output_bytes_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize output_bytes_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::encode_i64(buf, buf_len, new_pos, data_checksum_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize data_checksum_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::encode_i64(buf, buf_len, new_pos, meta_checksum_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to serialize meta_checksum_", KR(ret), K(pos), K(buf_len), K(new_pos));
|
||||
} else {
|
||||
pos = new_pos;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObArchiveBlockMeta::deserialize(const char* buf, const int64_t data_len, int64_t& pos)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
int64_t new_pos = pos;
|
||||
if ((NULL == buf) || (data_len <= 0)) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
ARCHIVE_LOG(TRACE, "invalid argument", KR(ret), KP(buf), K(data_len));
|
||||
} else if (OB_FAIL(serialization::decode_i16(buf, data_len, new_pos, &magic_))) {
|
||||
ARCHIVE_LOG(TRACE, "failed to deserialize magic_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::decode_i16(buf, data_len, new_pos, &version_))) {
|
||||
ARCHIVE_LOG(TRACE, "failed to deserialize version_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::decode_i32(buf, data_len, new_pos, &total_len_))) {
|
||||
ARCHIVE_LOG(TRACE, "failed to deserialize total_len_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::decode_i64(buf, data_len, new_pos, ×tamp_))) {
|
||||
ARCHIVE_LOG(TRACE, "failed to deserialize timestamp_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::decode_i64(buf, data_len, new_pos, &clog_epoch_id_))) {
|
||||
ARCHIVE_LOG(TRACE, "failed to deserialize clog_epoch_id_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::decode_i64(buf, data_len, new_pos, &accum_checksum_))) {
|
||||
ARCHIVE_LOG(TRACE, "failed to deserialize accum_checksum_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else if (OB_FAIL(
|
||||
serialization::decode_i64(buf, data_len, new_pos, reinterpret_cast<int64_t*>(&min_log_id_in_file_)))) {
|
||||
ARCHIVE_LOG(WARN, "failed to deserialize min_log_id_in_file_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::decode_i64(buf, data_len, new_pos, &min_log_ts_in_file_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to deserialize min_log_ts_in_file_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::decode_i64(buf, data_len, new_pos, reinterpret_cast<int64_t*>(&max_log_id_)))) {
|
||||
ARCHIVE_LOG(WARN, "failed to deserialize max_log_id_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::decode_i64(buf, data_len, new_pos, &max_checkpoint_ts_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to deserialize max_checkpoint_ts_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::decode_i64(buf, data_len, new_pos, &max_log_submit_ts_))) {
|
||||
ARCHIVE_LOG(WARN, "failed to deserialize max_log_submit_ts_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::decode_i64(buf, data_len, new_pos, &input_bytes_))) {
|
||||
ARCHIVE_LOG(TRACE, "failed to deserialize input_bytes_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::decode_i64(buf, data_len, new_pos, &output_bytes_))) {
|
||||
ARCHIVE_LOG(TRACE, "failed to deserialize output_bytes_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::decode_i64(buf, data_len, new_pos, &data_checksum_))) {
|
||||
ARCHIVE_LOG(TRACE, "failed to deserialize data_checksum_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else if (OB_FAIL(serialization::decode_i64(buf, data_len, new_pos, &meta_checksum_))) {
|
||||
ARCHIVE_LOG(TRACE, "failed to deserialize meta_checksum_", KR(ret), K(pos), K(data_len), K(new_pos));
|
||||
} else {
|
||||
pos = new_pos;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int64_t ObArchiveBlockMeta::get_serialize_size(void) const
|
||||
{
|
||||
int64_t size = 0;
|
||||
size += serialization::encoded_length_i16(magic_);
|
||||
size += serialization::encoded_length_i16(version_);
|
||||
size += serialization::encoded_length_i32(total_len_);
|
||||
size += serialization::encoded_length_i64(timestamp_);
|
||||
size += serialization::encoded_length_i64(clog_epoch_id_);
|
||||
size += serialization::encoded_length_i64(accum_checksum_);
|
||||
size += serialization::encoded_length_i64(min_log_id_in_file_);
|
||||
size += serialization::encoded_length_i64(min_log_ts_in_file_);
|
||||
size += serialization::encoded_length_i64(max_log_id_);
|
||||
size += serialization::encoded_length_i64(max_checkpoint_ts_);
|
||||
size += serialization::encoded_length_i64(max_log_submit_ts_);
|
||||
size += serialization::encoded_length_i64(input_bytes_);
|
||||
size += serialization::encoded_length_i64(output_bytes_);
|
||||
size += serialization::encoded_length_i64(data_checksum_);
|
||||
size += serialization::encoded_length_i64(meta_checksum_);
|
||||
return size;
|
||||
}
|
||||
|
||||
int ObArchiveBlockMeta::build_serialized_block(
|
||||
char* buf, const int64_t buf_len, const char* data_buf, const int64_t data_len, int64_t& pos)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
if (OB_ISNULL(buf) || (buf_len <= 0) || OB_ISNULL(data_buf) || (data_len <= 0)) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
ARCHIVE_LOG(ERROR, "invalid argument", K(ret), KP(buf), K(buf_len), KP(data_buf), K(data_len));
|
||||
} else if (OB_FAIL(generate_block_(data_buf, data_len))) {
|
||||
ARCHIVE_LOG(ERROR, "generate block failed.", K(ret), KP(buf), K(data_len));
|
||||
} else if (OB_FAIL(serialize(buf, buf_len, pos))) {
|
||||
ARCHIVE_LOG(ERROR, "serialize block_meta_ failed.", K(ret), KP(buf), K(buf_len), K(pos));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
} // namespace archive
|
||||
} // end namespace oceanbase
|
||||
Reference in New Issue
Block a user