hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
137a8f1f96f911e77808e462616f202ada1b9fe3
oceanbase/deps/oblib/src/lib/utility/utility.cpp
xuhuleon 137a8f1f96 support asan and fix several memory bug
2021-09-18 21:54:07 +08:00

1918 lines
52 KiB
C++
Raw Blame History

/**
* 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.
*/
#define USING_LOG_PREFIX LIB
#include "dirent.h"
#include "lib/utility/utility.h"
#include "lib/ob_define.h"
#include "util/easy_inet.h"
#include "common/rowkey/ob_rowkey.h"
#include "lib/time/ob_time_utility.h"
#include "lib/file/file_directory_utils.h"
#include "common/ob_range.h"
#include "lib/string/ob_sql_string.h"
#include "lib/stat/ob_diagnose_info.h"
#include "common/object/ob_object.h"
#include "lib/net/ob_addr.h"
#include "lib/json/ob_yson.h"
namespace oceanbase {
using namespace lib;
namespace common {
extern "C" {
void do_breakpad_init() __attribute__((weak));
void do_breakpad_init()
{}
}
char* parray(char* buf, int64_t len, int64_t* array, int size)
{
// As used in lbt, and lbt used when print error log.
// Can not print error log this function.
if (NULL != buf && len > 0 && NULL != array) {
int64_t pos = 0;
int64_t count = 0;
for (int64_t i = 0; i < size; i++) {
if (0 == i) {
count = snprintf(buf + pos, len - pos, "0x%lx", array[i]);
} else {
count = snprintf(buf + pos, len - pos, " 0x%lx", array[i]);
}
if (count >= 0 && pos + count < len) {
pos += count;
} else {
// buf not enough
break;
}
}
buf[pos] = 0;
}
return buf;
}
static __thread void* addrs[100];
char* lbt()
{
// As lbt used when print error log, can not print error log
// in this function and functions called.
static __thread char buf[LBT_BUFFER_LENGTH];
int size = backtrace(addrs, ARRAYSIZEOF(addrs));
return parray(buf, sizeof(buf), (int64_t*)addrs, size);
}
char* lbt(char* buf, int32_t len)
{
int size = backtrace(addrs, ARRAYSIZEOF(addrs));
return parray(buf, len, (int64_t*)addrs, size);
}
void hex_dump(const void* data, const int32_t size, const bool char_type /*= true*/,
const int32_t log_level /*= OB_LOG_LEVEL_DEBUG*/)
{
if (OB_LOGGER.get_log_level() < log_level) {
return;
}
/* dumps size bytes of *data to stdout. Looks like:
* [0000] 75 6E 6B 6E 6F 77 6E 20
* 30 FF 00 00 00 00 39 00 unknown 0.....9.
* (in a single line of course)
*/
unsigned const char* p = (unsigned char*)data;
unsigned char c = 0;
int n = 0;
char bytestr[4] = {0};
char addrstr[10] = {0};
char hexstr[16 * 3 + 5] = {0};
char charstr[16 * 1 + 5] = {0};
for (n = 1; n <= size; n++) {
if (n % 16 == 1) {
/* store address for this line */
IGNORE_RETURN snprintf(addrstr, sizeof(addrstr), "%.4x", (int)((unsigned long)p - (unsigned long)data));
}
c = *p;
if (isprint(c) == 0) {
c = '.';
}
/* store hex str (for left side) */
IGNORE_RETURN snprintf(bytestr, sizeof(bytestr), "%02X ", *p);
strncat(hexstr, bytestr, sizeof(hexstr) - strlen(hexstr) - 1);
/* store char str (for right side) */
IGNORE_RETURN snprintf(bytestr, sizeof(bytestr), "%c", c);
strncat(charstr, bytestr, sizeof(charstr) - strlen(charstr) - 1);
if (n % 16 == 0) {
/* line completed */
if (char_type)
_OB_NUM_LEVEL_LOG(log_level, "[%ld] [%4.4s] %-50.50s %s\n", pthread_self(), addrstr, hexstr, charstr);
else
_OB_NUM_LEVEL_LOG(log_level, "[%ld] [%4.4s] %-50.50s\n", pthread_self(), addrstr, hexstr);
hexstr[0] = 0;
charstr[0] = 0;
} else if (n % 8 == 0) {
/* half line: add whitespaces */
strncat(hexstr, " ", sizeof(hexstr) - strlen(hexstr) - 1);
strncat(charstr, " ", sizeof(charstr) - strlen(charstr) - 1);
}
p++; /* next byte */
}
if (strlen(hexstr) > 0) {
/* print rest of buffer if not empty */
if (char_type)
_OB_NUM_LEVEL_LOG(log_level, "[%ld] [%4.4s] %-50.50s %s\n", pthread_self(), addrstr, hexstr, charstr);
else
_OB_NUM_LEVEL_LOG(log_level, "[%ld] [%4.4s] %-50.50s\n", pthread_self(), addrstr, hexstr);
}
}
int32_t parse_string_to_int_array(const char* line, const char del, int32_t* array, int32_t& size)
{
int ret = 0;
ObArenaAllocator allocator;
const char* start = line;
const char* p = NULL;
char* buffer = NULL;
if (NULL == line || NULL == array || size <= 0) {
ret = OB_INVALID_ARGUMENT;
}
if (NULL == (buffer = static_cast<char*>(allocator.alloc(OB_MAX_ROW_KEY_LENGTH)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
}
int32_t idx = 0;
if (OB_SUCC(ret)) {
while (OB_SUCC(ret) && NULL != start) {
p = strchr(start, del);
if (NULL != p) {
memset(buffer, 0, OB_MAX_ROW_KEY_LENGTH);
strncpy(buffer, start, p - start);
if (strlen(buffer) > 0) {
if (idx >= size) {
ret = OB_SIZE_OVERFLOW;
break;
} else {
array[idx++] = static_cast<int32_t>(strtol(buffer, NULL, 10));
}
}
start = p + 1;
} else {
if (strlen(start) > OB_MAX_ROW_KEY_LENGTH - 1) {
ret = OB_SIZE_OVERFLOW;
break;
} else {
memset(buffer, 0, OB_MAX_ROW_KEY_LENGTH);
strcpy(buffer, start);
if (strlen(buffer) > 0) {
if (idx >= size) {
ret = OB_SIZE_OVERFLOW;
break;
} else {
array[idx++] = static_cast<int32_t>(strtol(buffer, NULL, 10));
}
}
break;
}
}
}
if (OB_SUCC(ret)) {
size = idx;
}
}
if (NULL != buffer) {
allocator.free(buffer);
}
return ret;
}
int escape_enter_symbol(char* buffer, const int64_t length, int64_t& pos, const char* src)
{
int ret = OB_SUCCESS;
int64_t copy_size = pos;
int64_t src_len = strlen(src);
if (pos + src_len >= length || NULL == buffer) {
ret = OB_BUF_NOT_ENOUGH;
} else {
char escape = 0;
for (int i = 0; OB_SUCC(ret) && i < src_len; ++i) {
escape = 0;
switch (src[i]) {
case '\n':
escape = 'n';
break;
default:
break;
}
if (escape != 0) {
if (copy_size >= length - 2) {
ret = OB_BUF_NOT_ENOUGH;
break;
}
buffer[pos++] = '\\';
buffer[pos++] = escape;
copy_size += 2;
} else {
if (copy_size >= length - 1) {
ret = OB_BUF_NOT_ENOUGH;
break;
}
buffer[pos++] = src[i];
copy_size += 1;
}
}
if (copy_size < length) {
buffer[pos] = '\0';
} else {
ret = OB_BUF_NOT_ENOUGH;
}
}
return ret;
}
/**
* only escape " and \, used to stringify range2str
*/
int escape_range_string(char* buffer, const int64_t length, int64_t& pos, const ObString& in)
{
int ret = OB_SUCCESS;
int64_t copy_size = 0;
if (pos + in.length() >= length || NULL == buffer) {
ret = OB_BUF_NOT_ENOUGH;
} else {
char escape = 0;
;
for (int i = 0; OB_SUCC(ret) && i < in.length(); ++i) {
escape = 0;
switch (in.ptr()[i]) {
case '"':
escape = '"';
break;
case '\\':
escape = '\\';
break;
default:
break;
}
if (escape != 0) {
if (copy_size >= length - 2) {
ret = OB_BUF_NOT_ENOUGH;
break;
}
buffer[pos++] = '\\';
buffer[pos++] = escape;
copy_size += 2;
} else {
if (copy_size >= length - 1) {
ret = OB_BUF_NOT_ENOUGH;
break;
}
buffer[pos++] = in.ptr()[i];
copy_size += 1;
}
}
}
return ret;
}
int convert_comment_str(char* comment_str)
{
int ret = OB_SUCCESS;
if (comment_str == NULL) {
ret = OB_INVALID_ARGUMENT;
} else if (OB_SUCCESS != (ret = replace_str(comment_str, strlen(comment_str), "\\n", "\n"))) {
_OB_LOG(WARN, "replace \\n to enter failed, src_str=%s, ret=%d", comment_str, ret);
}
return ret;
}
bool is2n(int64_t input)
{
return (((~input + 1) & input) == input);
};
bool all_zero(const char* buffer, const int64_t size)
{
bool bret = true;
const char* buffer_end = buffer + size;
const char* start = (char*)upper_align((int64_t)buffer, sizeof(int64_t));
start = std::min(start, buffer_end);
const char* end = (char*)lower_align((int64_t)(buffer + size), sizeof(int64_t));
end = std::max(end, buffer);
bret = all_zero_small(buffer, start - buffer);
if (bret) {
bret = all_zero_small(end, buffer + size - end);
}
if (bret) {
const char* iter = start;
while (iter < end) {
if (0 != *((int64_t*)iter)) {
bret = false;
break;
}
iter += sizeof(int64_t);
}
}
return bret;
};
bool all_zero_small(const char* buffer, const int64_t size)
{
bool bret = true;
if (NULL != buffer) {
for (int64_t i = 0; i < size; i++) {
if (0 != *(buffer + i)) {
bret = false;
break;
}
}
}
return bret;
}
char* str_trim(char* str)
{
char *p = str, *sa = str;
while (*p) {
if (*p != ' ') {
*str++ = *p;
}
p++;
}
*str = 0;
return sa;
}
char* ltrim(char* str)
{
char* p = str;
while (p != NULL && *p != '\0' && isspace(*p)) {
++p;
}
return p;
}
char* rtrim(char* str)
{
if ((str != NULL) && *str != '\0') {
char* p = str + strlen(str) - 1;
while ((p > str) && isspace(*p)) {
--p;
}
*(p + 1) = '\0';
}
return str;
}
const char* inet_ntoa_s(char* buffer, size_t n, const uint64_t ipport)
{
buffer[0] = '\0';
uint32_t ip = (uint32_t)(ipport & 0xffffffff);
int port = (int)((ipport >> 32) & 0xffff);
unsigned char* bytes = (unsigned char*)&ip;
if (port > 0) {
IGNORE_RETURN snprintf(buffer, n, "%d.%d.%d.%d:%d", bytes[0], bytes[1], bytes[2], bytes[3], port);
} else {
IGNORE_RETURN snprintf(buffer, n, "%d.%d.%d.%d:-1", bytes[0], bytes[1], bytes[2], bytes[3]);
}
return buffer;
}
const char* inet_ntoa_s(char* buffer, size_t n, const uint32_t ip)
{
buffer[0] = '\0';
unsigned char* bytes = (unsigned char*)&ip;
IGNORE_RETURN snprintf(buffer, n, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3]);
return buffer;
}
const char* time2str(const int64_t time_us, const char* format)
{
// FIXME: To Be Removed
static const int32_t BUFFER_SIZE = 1024;
static __thread char buffer[10][BUFFER_SIZE];
static __thread uint64_t i = 0;
buffer[i % 10][0] = '\0';
struct tm time_struct;
int64_t time_s = time_us / 1000000;
int64_t cur_second_time_us = time_us % 1000000;
if (NULL != localtime_r(&time_s, &time_struct)) {
int64_t pos = strftime(buffer[i % 10], BUFFER_SIZE, format, &time_struct);
if (pos < BUFFER_SIZE) {
IGNORE_RETURN snprintf(&buffer[i % 10][pos], BUFFER_SIZE - pos, ".%ld %ld", cur_second_time_us, time_us);
}
}
return buffer[i++ % 10];
}
void print_rowkey(FILE* fd, ObString& rowkey)
{
char* pchar = rowkey.ptr();
for (int i = 0; i < rowkey.length(); ++i, pchar++) {
if (isprint(*pchar) != 0) {
fprintf(fd, "%c", *pchar);
} else {
fprintf(fd, "\\%hhu", *pchar);
}
}
}
int mem_chunk_serialize(char* buf, int64_t len, int64_t& pos, const char* data, int64_t data_len)
{
int err = OB_SUCCESS;
int64_t tmp_pos = pos;
if (NULL == buf || len <= 0 || pos < 0 || pos > len || NULL == data || 0 > data_len) {
err = OB_INVALID_ARGUMENT;
} else if (OB_SUCCESS != (err = serialization::encode_i64(buf, len, tmp_pos, data_len))) {
_OB_LOG(ERROR, "encode_i64(buf=%p, len=%ld, pos=%ld, i=%ld)=>%d", buf, len, tmp_pos, data_len, err);
} else if (tmp_pos + data_len > len) {
err = OB_SERIALIZE_ERROR;
} else {
MEMCPY(buf + tmp_pos, data, data_len);
tmp_pos += data_len;
pos = tmp_pos;
}
return err;
}
int mem_chunk_deserialize(const char* buf, int64_t len, int64_t& pos, char* data, int64_t data_len, int64_t& real_len)
{
int err = OB_SUCCESS;
int64_t tmp_pos = pos;
if (NULL == buf || len <= 0 || pos < 0 || pos > len || NULL == data || data_len < 0) {
err = OB_INVALID_ARGUMENT;
} else if (OB_SUCCESS != (err = serialization::decode_i64(buf, len, tmp_pos, &real_len))) {
_OB_LOG(ERROR, "decode_i64(buf=%p, len=%ld, pos=%ld, i=%ld)=>%d", buf, len, tmp_pos, real_len, err);
} else if (real_len > data_len || tmp_pos + real_len > len) {
err = OB_DESERIALIZE_ERROR;
} else {
MEMCPY(data, buf + tmp_pos, real_len);
tmp_pos += real_len;
pos = tmp_pos;
}
return err;
}
int64_t min(const int64_t x, const int64_t y)
{
return x > y ? y : x;
}
int64_t max(const int64_t x, const int64_t y)
{
return x < y ? y : x;
}
int get_double_expand_size(int64_t& current_size, const int64_t limit_size)
{
int ret = OB_SUCCESS;
int64_t new_size = current_size << 1;
if (current_size > limit_size) {
ret = OB_SIZE_OVERFLOW;
} else if (new_size > limit_size) {
current_size = limit_size;
} else {
current_size = new_size;
}
return ret;
}
uint16_t bswap16(uint16_t a)
{
return static_cast<uint16_t>(((a >> 8) & 0xFFU) | ((a << 8) & 0xFF00U));
}
bool str_isprint(const char* str, const int64_t length)
{
bool bret = false;
if (NULL != str && 0 != length) {
bret = true;
for (int64_t i = 0; i < length; i++) {
if (!isprint(str[i])) {
bret = false;
break;
}
}
}
return bret;
}
int replace_str(char* src_str, const int64_t src_str_buf_size, const char* match_str, const char* replace_str)
{
int ret = OB_SUCCESS;
int64_t str_len = 0;
int64_t match_str_len = 0;
int64_t replace_str_len = 0;
const char* find_pos = NULL;
char new_str[OB_MAX_EXPIRE_INFO_STRING_LENGTH];
if (NULL == src_str || src_str_buf_size <= 0 || NULL == match_str || NULL == replace_str) {
_OB_LOG(WARN,
"invalid param, src_str=%p, src_str_buf_size=%ld, "
"match_str=%p, replace_str=%p",
src_str,
src_str_buf_size,
match_str,
replace_str);
ret = OB_ERROR;
} else if (NULL != (find_pos = strstr(src_str, match_str))) {
match_str_len = strlen(match_str);
replace_str_len = strlen(replace_str);
while (OB_SUCC(ret) && NULL != find_pos) {
str_len = find_pos - src_str + replace_str_len + strlen(find_pos + match_str_len);
if (str_len >= OB_MAX_EXPIRE_INFO_STRING_LENGTH || str_len >= src_str_buf_size) {
_OB_LOG(WARN,
"str after replace is too large, new_size=%ld, "
"new_buf_size=%ld, src_str_buf_size=%ld",
str_len,
OB_MAX_EXPIRE_INFO_STRING_LENGTH,
src_str_buf_size);
ret = OB_ERROR;
break;
} else {
memset(new_str, 0, OB_MAX_EXPIRE_INFO_STRING_LENGTH);
strncpy(new_str, src_str, find_pos - src_str);
strcat(new_str, replace_str);
strcat(new_str, find_pos + match_str_len);
strcpy(src_str, new_str);
}
find_pos = strstr(src_str, match_str);
}
}
return ret;
}
int get_ethernet_speed(const char* devname, int64_t& speed)
{
int rc = OB_SUCCESS;
if (NULL == devname) {
_OB_LOG(WARN, "invalid devname %p", devname);
rc = OB_INVALID_ARGUMENT;
} else {
rc = get_ethernet_speed(ObString::make_string(devname), speed);
}
return rc;
}
int get_ethernet_speed(const ObString& devname, int64_t& speed)
{
int rc = OB_SUCCESS;
bool exist = false;
char path[OB_MAX_FILE_NAME_LENGTH];
static int dev_file_exist = 1;
if (0 == devname.length()) {
_OB_LOG(WARN, "empty devname");
rc = OB_INVALID_ARGUMENT;
} else {
IGNORE_RETURN snprintf(path, sizeof(path), "/sys/class/net/%.*s", devname.length(), devname.ptr());
if (OB_SUCCESS != (rc = FileDirectoryUtils::is_exists(path, exist)) || !exist) {
if (dev_file_exist) {
_OB_LOG(WARN, "path %s not exist", path);
dev_file_exist = 0;
}
rc = OB_FILE_NOT_EXIST;
}
}
if (OB_SUCCESS != rc) {
} else {
CharArena alloc;
ObString str;
IGNORE_RETURN snprintf(path, sizeof(path), "/sys/class/net/%.*s/bonding/", devname.length(), devname.ptr());
if (OB_SUCCESS != (rc = FileDirectoryUtils::is_exists(path, exist))) {
LIB_LOG(WARN, "check net file if exists failed.", K(rc));
} else if (exist) {
IGNORE_RETURN snprintf(path, sizeof(path), "/sys/class/net/%.*s/bonding/slaves", devname.length(), devname.ptr());
if (OB_SUCCESS != (rc = load_file_to_string(path, alloc, str))) {
_OB_LOG(WARN, "load file %s failed, rc %d", path, rc);
} else if (0 == str.length()) {
_OB_LOG(WARN, "can't get slave ethernet");
rc = OB_ERROR;
} else {
int len = 0;
while (len < str.length() && !isspace(str.ptr()[len])) {
len++;
}
IGNORE_RETURN snprintf(path, sizeof(path), "/sys/class/net/%.*s/speed", len, str.ptr());
}
} else {
IGNORE_RETURN snprintf(path, sizeof(path), "/sys/class/net/%.*s/speed", devname.length(), devname.ptr());
}
if (OB_SUCCESS == rc) {
if (OB_SUCCESS != (rc = load_file_to_string(path, alloc, str))) {
_OB_LOG(WARN, "load file %s failed, rc %d", path, rc);
} else {
speed = atoll(str.ptr());
speed = speed * 1024 * 1024 / 8;
}
}
}
return rc;
}
int deep_copy_obj(ObIAllocator& allocator, const ObObj& src, ObObj& dst)
{
int ret = OB_SUCCESS;
if (!src.need_deep_copy()) {
dst = src;
} else {
char* buf = NULL;
int64_t size = src.get_deep_copy_size();
int64_t pos = 0;
if (size > 0) {
if (NULL == (buf = static_cast<char*>(allocator.alloc(size)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("Fail to allocate memory, ", K(size), K(ret));
} else if (OB_FAIL(dst.deep_copy(src, buf, size, pos))) {
LOG_WARN("Fail to deep copy obj, ", K(ret));
} else {
} // do nothing
} else {
dst = src;
}
}
return ret;
}
int deep_copy_objparam(ObIAllocator& allocator, const ObObjParam& src, ObObjParam& dst)
{
int ret = OB_SUCCESS;
if (!src.need_deep_copy()) {
dst = src;
} else if (OB_FAIL(deep_copy_obj(allocator, src, dst))) {
LOG_WARN("failed to deep copy obj", K(ret));
} else {
dst.set_accuracy(src.get_accuracy());
dst.unset_result_flag(dst.get_result_flag());
dst.set_result_flag(src.get_result_flag());
dst.set_param_flag(src.get_param_flag());
dst.set_param_meta(src.get_param_meta());
}
return ret;
}
bool is_case_space_equal(const char* s1, int64_t s1_len, const char* s2, int64_t s2_len)
{
int result = true;
// Check input
if (NULL == s1 || NULL == s2 || s1_len < 0 || s2_len < 0) {
result = false;
_OB_LOG(ERROR, "Invalid argument, input arguments include NULL pointer or string length is less than zero.");
} else if (s1 != s2) { // If s1 == s2,return 1
while (1) {
// Left trim
while (s1_len != 0 && isspace(*s1)) {
--s1_len;
++s1;
}
while (s2_len != 0 && isspace(*s2)) {
--s2_len;
++s2;
}
// To stop while(1).
if (0 == s1_len && 0 == s2_len) {
result = true;
break;
} else if (0 == s1_len || 0 == s2_len) {
result = false;
break;
}
if (false == result) {
break;
}
// Compare chars bettween s1 and s2
while (s1_len != 0 && s2_len != 0) {
if (tolower(*s1) != tolower(*s2)) {
result = false;
break;
}
int s1_is_space = 0;
int s2_is_space = 0;
if (--s1_len != 0) {
s1_is_space = isspace(*(++s1));
}
if (--s2_len != 0) {
s2_is_space = isspace(*(++s2));
}
if (s1_is_space != s2_is_space) {
result = false;
break;
} else if (s1_is_space && s2_is_space) {
break;
}
} // end of while (s1_len != 0 && s2_len != 0)
} // end of while(1)
} // end of else if (s1 != s2)
return result;
}
bool is_n_case_space_equal(const char* s1, int64_t s1_len, const char* s2, int64_t s2_len, int64_t cmp_len)
{
bool result = true;
// Check input
if (NULL == s1 || NULL == s2 || s1_len < 0 || s2_len < 0) {
result = false;
_OB_LOG(ERROR, "Invalid argument, input arguments include NULL pointer or string length is less than zero.");
} else if (s1 != s2) { // If s1 == s2,return 1
while (1) {
// Left trim
while (s1_len != 0 && isspace(*s1)) {
--s1_len;
++s1;
}
while (s2_len != 0 && isspace(*s2)) {
--s2_len;
++s2;
}
// To stop while(1).
if (cmp_len <= 0 || (0 == s1_len && 0 == s2_len)) {
result = true;
break;
} else if (0 == s1_len || 0 == s2_len) {
result = false;
break;
}
if (false == result) {
break;
}
// Compare chars bettween s1 and s2
while (cmp_len > 0 && s1_len != 0 && s2_len != 0) {
if (tolower(*s1) != tolower(*s2)) {
result = false;
break;
}
--cmp_len;
int s1_is_space = 0;
int s2_is_space = 0;
if (--s1_len != 0) {
s1_is_space = isspace(*(++s1));
}
if (--s2_len != 0) {
s2_is_space = isspace(*(++s2));
}
if (s1_is_space != s2_is_space) {
result = false;
break;
} else if (s1_is_space && s2_is_space) {
--cmp_len;
break;
}
} // end of while (cmp_len > 0 && s1_len != 0 && s2_len != 0)
} // end of while(1)
} // end of if (s1 != s2)
return result;
}
int wild_compare(const char* str, const char* wild_str, const bool str_is_pattern)
{
const char wild_many = '%';
const char wild_one = '_';
const char wild_prefix = '\\';
char cmp = 0;
const int EQUAL = 0;
const int UNEQUAL = 1;
const int UNKOWN = -1;
int ret = UNKOWN;
if (NULL != str && NULL != wild_str) {
while (*wild_str) {
while (*wild_str && *wild_str != wild_many && *wild_str != wild_one) {
if (*wild_str == wild_prefix && wild_str[1]) {
wild_str++;
if (str_is_pattern && *str++ != wild_prefix) {
ret = UNEQUAL;
break;
}
}
if (*wild_str++ != *str++) {
ret = UNEQUAL;
break;
}
}
if (UNKOWN != ret) {
break;
}
if (!*wild_str) {
ret = (*str != 0) ? UNEQUAL : EQUAL;
break;
}
if (*wild_str++ == wild_one) {
if (!*str || (str_is_pattern && *str == wild_many)) {
ret = UNEQUAL; // One char; skip
break;
}
if (*str++ == wild_prefix && str_is_pattern && *str) {
str++;
}
} else { // Found wild_many
while (str_is_pattern && *str == wild_many) {
str++;
}
for (; *wild_str == wild_many || *wild_str == wild_one; wild_str++) {
if (*wild_str == wild_many) {
while (str_is_pattern && *str == wild_many)
str++;
} else {
if (str_is_pattern && *str == wild_prefix && str[1]) {
str += 2;
} else if (!*str++) {
ret = UNEQUAL;
break;
}
}
}
if (!*wild_str) {
ret = EQUAL; // wild_many as last char: OK
break;
}
if ((cmp = *wild_str) == wild_prefix && wild_str[1] && !str_is_pattern) {
cmp = wild_str[1];
}
for (;; str++) {
while (*str && *str != cmp) {
str++;
}
if (!*str) {
ret = UNEQUAL;
break;
}
if (wild_compare(str, wild_str, str_is_pattern) == 0) {
ret = EQUAL;
break;
}
}
}
}
if (UNKOWN == ret) {
ret = (*str != 0) ? UNEQUAL : EQUAL;
}
}
return ret;
}
int wild_compare(const ObString& str, const ObString& wild_str, const bool str_is_pattern)
{
const char wild_many = '%';
const char wild_one = '_';
const char wild_prefix = '\\';
char cmp = 0;
const int EQUAL = 0;
const int UNEQUAL = 1;
const int UNKOWN = -1;
int ret = UNKOWN;
const char* str_ptr = str.ptr();
const char* wild_ptr = wild_str.ptr();
const ObString::obstr_size_t str_length = str.length();
const ObString::obstr_size_t wild_length = wild_str.length();
ObString::obstr_size_t str_pos = 0;
ObString::obstr_size_t wild_pos = 0;
#define INC_STR() \
str_ptr++; \
str_pos++;
#define INC_WILD() \
wild_ptr++; \
wild_pos++;
if (NULL != str_ptr && NULL != wild_ptr) {
while (wild_pos < wild_length) {
// check char without wild_many or wild_one.
while (wild_pos < wild_length && *wild_ptr != wild_many && *wild_ptr != wild_one) {
if (*wild_ptr == wild_prefix && (wild_pos + 1 < wild_length)) {
INC_WILD();
if (str_is_pattern) {
if (str_pos == str_length || (str_pos < str_length && *str_ptr != wild_prefix)) {
ret = UNEQUAL;
break;
}
INC_STR();
}
}
if ((str_pos >= str_length || (str_pos < str_length && wild_pos < wild_length && *wild_ptr != *str_ptr))) {
ret = UNEQUAL;
break;
}
INC_STR();
INC_WILD();
}
if (UNKOWN != ret) {
break;
}
if (wild_pos >= wild_length) {
ret = (str_pos < str_length) ? UNEQUAL : EQUAL;
break;
}
if (wild_pos < wild_length && *wild_ptr == wild_one) {
INC_WILD();
if (str_pos >= str_length || (str_is_pattern && (str_pos < str_length && *str_ptr == wild_many))) {
ret = UNEQUAL; // One char; skip
break;
}
if (str_pos + 1 < str_length && *str_ptr == wild_prefix && str_is_pattern) {
INC_STR();
}
INC_STR();
} else {
INC_WILD();
while (str_is_pattern && str_pos < str_length && *str_ptr == wild_many) {
INC_STR();
}
for (; wild_pos < wild_length && (*wild_ptr == wild_many || *wild_ptr == wild_one); wild_ptr++, wild_pos++) {
if (*wild_ptr == wild_many) {
while (str_is_pattern && str_pos < str_length && *str_ptr == wild_many) {
INC_STR();
}
} else {
if (str_is_pattern && str_pos + 1 < str_length && *str_ptr == wild_prefix) {
INC_STR();
} else if (str_pos >= str_length) {
ret = UNEQUAL;
break;
}
INC_STR();
}
}
if (wild_pos >= wild_length) {
ret = EQUAL; // wild_many as last char: OK
break;
}
if ((cmp = *wild_ptr) == wild_prefix && wild_pos + 1 < wild_length && !str_is_pattern) {
cmp = wild_ptr[1];
}
for (;; str_pos++, str_ptr++) {
while (str_pos < str_length && *str_ptr != cmp) {
INC_STR();
}
if (str_pos >= str_length) {
ret = EQUAL;
break;
}
if (wild_compare(ObString(str_length - str_pos, str_ptr),
ObString(wild_length - wild_pos, wild_ptr),
str_is_pattern) == 0) {
ret = EQUAL;
break;
}
}
}
}
if (UNKOWN == ret) {
ret = (str_pos < str_length) ? UNEQUAL : EQUAL;
}
}
#undef INC_STR
#undef INC_WILD
return ret;
}
uint64_t get_sort(uint count, ...)
{
const char wild_many = '%';
const char wild_one = '_';
const char wild_prefix = '\\';
va_list args;
va_start(args, count);
ulong sort = 0;
// Should not use this function with more than 8 arguments for compare.
if (count <= 8) {
while (count--) {
char* start = NULL;
char* str = va_arg(args, char*);
uint chars = 0;
uint wild_pos = 0; // first wildcard position
if ((start = str)) {
for (; *str; str++) {
if (*str == wild_prefix && str[1]) {
str++;
} else if (*str == wild_many || *str == wild_one) {
wild_pos = (uint)(str - start) + 1;
break;
}
chars = 128; // Marker that chars existed
}
}
sort = (sort << 8) + (wild_pos ? min(wild_pos, 127) : chars);
}
}
va_end(args);
return sort;
}
uint64_t get_sort(const ObString& str)
{
const char wild_many = '%';
const char wild_one = '_';
const char wild_prefix = '\\';
uint64_t sort = 0;
if (str.length() > 0) {
const char* str_ptr = str.ptr();
ObString::obstr_size_t str_pos = 0;
const ObString::obstr_size_t str_length = str.length();
uint32_t specific_chars = 128;
uint32_t wild_pos = 0; // first wildcard position
for (; str_pos < str_length; str_ptr++, str_pos++) {
if (str_pos + 1 < str_length && *str_ptr == wild_prefix) {
str_ptr++;
str_pos++;
} else if (str_pos < str_length && (*str_ptr == wild_many || *str_ptr == wild_one)) {
wild_pos = str_pos + 1;
break;
}
}
sort = wild_pos ? min(wild_pos, 127) : specific_chars;
}
return sort;
}
bool prefix_match(const char* prefix, const char* str)
{
bool b_ret = false;
if (NULL == prefix || NULL == str) {
} else {
size_t prefix_len = strlen(prefix);
size_t str_len = strlen(str);
if (prefix_len > str_len) {
} else if (0 == MEMCMP(prefix, str, prefix_len)) {
b_ret = true;
}
}
return b_ret;
}
int str_cmp(const void* v1, const void* v2)
{
int ret = 0;
if (NULL == v1) {
ret = -1;
} else if (NULL == v2) {
ret = 1;
} else {
ret = strcmp((const char*)v1, (const char*)v2);
}
return ret;
}
const char* get_default_if()
{
static char ifname[128] = {};
int found = 0;
FILE* file = NULL;
file = fopen("/proc/net/route", "r");
if (file) {
char dest[16] = {};
char gw[16] = {};
char remain[1024 + 1] = {};
if (1 == fscanf(file, "%1024[^\n]\n", remain)) {
while (1) {
int r = fscanf(file, "%127s\t%15s\t%15s\t%1023[^\n]\n", ifname, dest, gw, remain);
if (r < 4) {
break;
}
if (MEMCMP(gw, "00000000", 8) != 0) {
found = 1;
break;
}
}
}
fclose(file);
}
if (!found) {
ifname[0] = '\0';
}
return ifname;
}
int sql_append_hex_escape_str(const ObString& str, ObSqlString& sql)
{
int ret = OB_SUCCESS;
const int64_t need_len = sql.length() + str.length() * 2 + 3; // X''
if (OB_FAIL(sql.reserve(need_len))) {
LOG_WARN("reserve sql failed, ", K(ret));
} else if (OB_FAIL(sql.append("X'"))) {
LOG_WARN("append string failed", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < str.length(); ++i) {
if (OB_FAIL(sql.append_fmt("%02X", static_cast<uint8_t>(str.ptr()[i])))) {
LOG_WARN("append string failed", K(ret), K(i));
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(sql.append("'"))) {
LOG_WARN("append string failed", K(ret));
}
}
return ret;
}
static int pidfile_test(const char* pidfile)
{
int ret = OB_SUCCESS;
int fd = open(pidfile, O_RDONLY);
if (fd < 0) {
ret = OB_FILE_NOT_EXIST;
} else {
if (lockf(fd, F_TEST, 0) != 0) {
ret = OB_ERROR;
}
close(fd);
}
return ret;
}
static int read_pid(const char* pidfile, long& pid)
{
int ret = OB_SUCCESS;
char buf[32] = {};
int fd = open(pidfile, O_RDONLY);
if (fd < 0) {
LOG_ERROR("can't open pid file", K(pidfile), K(errno));
ret = OB_FILE_NOT_EXIST;
} else if (read(fd, buf, sizeof(buf)) <= 0) {
LOG_ERROR("fail to read pid from file", K(pidfile), K(errno));
ret = OB_IO_ERROR;
} else {
pid = strtol(buf, NULL, 10);
}
if (fd > 0) {
close(fd);
}
return ret;
}
static int use_daemon()
{
int ret = OB_SUCCESS;
const int nochdir = 1;
const int noclose = 0;
if (daemon(nochdir, noclose) < 0) {
LOG_ERROR("create daemon process fail", K(errno));
ret = OB_ERR_SYS;
}
reset_tid_cache();
// bt("enable_preload_bt") = 1;
return ret;
}
int start_daemon(const char* pidfile)
{
int ret = OB_SUCCESS;
ret = pidfile_test(pidfile);
if (ret != OB_SUCCESS && ret != OB_FILE_NOT_EXIST) {
LOG_ERROR("pid already exists");
} else {
ret = OB_SUCCESS;
}
// start daemon
if (OB_SUCC(ret) && OB_FAIL(use_daemon())) {
LOG_ERROR("create daemon process fail", K(ret));
}
if (OB_SUCC(ret)) {
int fd = open(pidfile, O_RDWR | O_CREAT, 0600);
if (fd < 0) { // open pidfile fail
LOG_ERROR("can't open pid file", K(pidfile), K(fd), K(errno));
ret = OB_IO_ERROR;
} else if (lockf(fd, F_TLOCK, 0) < 0) { // other process has locked it
long pid = 0;
if (OB_FAIL(read_pid(pidfile, pid))) {
LOG_ERROR("read pid fail", K(pidfile), K(ret));
} else {
LOG_ERROR("process is running", K(pid));
}
close(fd);
} else { // I hold the lock, won't close this fd.
if (ftruncate(fd, 0) < 0) {
LOG_ERROR("ftruncate pid file fail", K(pidfile), K(errno));
ret = OB_IO_ERROR;
} else {
char buf[32] = {};
IGNORE_RETURN snprintf(buf, sizeof(buf), "%d", getpid());
ssize_t len = strlen(buf);
ssize_t nwrite = write(fd, buf, len);
if (len != nwrite) {
LOG_ERROR("write pid file fail", K(pidfile), K(errno));
ret = OB_IO_ERROR;
}
}
}
}
return ret;
}
int ob_alloc_printf(ObString& result, ObIAllocator& alloc, const char* fmt, va_list ap)
{
int ret = OB_SUCCESS;
va_list ap2;
va_copy(ap2, ap);
int64_t n = vsnprintf(NULL, 0, fmt, ap);
if (n < 0) {
LOG_ERROR("vsnprintf failed", K(n), K(errno));
ret = OB_ERR_SYS;
} else {
char* buf = static_cast<char*>(alloc.alloc(n + 1));
if (NULL == buf) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("no memory");
} else {
int64_t n2 = vsnprintf(buf, n + 1, fmt, ap2);
if (n2 < 0) {
LOG_ERROR("vsnprintf failed", K(n), K(errno));
ret = OB_ERR_SYS;
} else if (n != n2) {
LOG_ERROR("vsnprintf failed", K(n), K(n2));
ret = OB_ERR_SYS;
} else {
result.assign_ptr(buf, static_cast<int32_t>(n));
}
}
}
return ret;
}
int ob_alloc_printf(ObString& result, ObIAllocator& alloc, const char* fmt, ...)
{
va_list ap;
va_start(ap, fmt);
int ret = ob_alloc_printf(result, alloc, fmt, ap);
va_end(ap);
return ret;
}
#define CLICK_STR(i) has_click_str ? click_str_[(i)] : ""
#define EQUAL_STR has_click_str ? "=" : ""
#define COMMA_STR has_click_str ? ", " : ","
#define COMMA_STR_LEN has_click_str ? 2 : 1
#define FSTR "%s%s%d%s"
#define VSTR(i) CLICK_STR(i), EQUAL_STR, click_[i], COMMA_STR
int64_t ObTimeGuard::to_string(char* buf, const int64_t buf_len) const
{
int64_t pos = 0;
int64_t i = 0;
bool has_click_str = (click_count_ > 0 && NULL != click_str_[0]);
databuff_printf(buf,
buf_len,
pos,
"time guard '%s' cost too much time, used=%ld%s",
owner_,
common::ObTimeUtility::fast_current_time() - start_ts_,
click_count_ > 0 ? ", time_dist: " : "");
while ((i + 8) <= click_count_) {
databuff_printf(buf,
buf_len,
pos,
FSTR FSTR FSTR FSTR FSTR FSTR FSTR FSTR,
VSTR(i),
VSTR(i + 1),
VSTR(i + 2),
VSTR(i + 3),
VSTR(i + 4),
VSTR(i + 5),
VSTR(i + 6),
VSTR(i + 7));
i = i + 8;
}
switch (click_count_ - i) {
case 0: {
break;
}
case 1: {
databuff_printf(buf, buf_len, pos, FSTR, VSTR(i));
break;
}
case 2: {
databuff_printf(buf, buf_len, pos, FSTR FSTR, VSTR(i), VSTR(i + 1));
break;
}
case 3: {
databuff_printf(buf, buf_len, pos, FSTR FSTR FSTR, VSTR(i), VSTR(i + 1), VSTR(i + 2));
break;
}
case 4: {
databuff_printf(buf, buf_len, pos, FSTR FSTR FSTR FSTR, VSTR(i), VSTR(i + 1), VSTR(i + 2), VSTR(i + 3));
break;
}
case 5: {
databuff_printf(
buf, buf_len, pos, FSTR FSTR FSTR FSTR FSTR, VSTR(i), VSTR(i + 1), VSTR(i + 2), VSTR(i + 3), VSTR(i + 4));
break;
}
case 6: {
databuff_printf(buf,
buf_len,
pos,
FSTR FSTR FSTR FSTR FSTR FSTR,
VSTR(i),
VSTR(i + 1),
VSTR(i + 2),
VSTR(i + 3),
VSTR(i + 4),
VSTR(i + 5));
break;
}
case 7: {
databuff_printf(buf,
buf_len,
pos,
FSTR FSTR FSTR FSTR FSTR FSTR FSTR,
VSTR(i),
VSTR(i + 1),
VSTR(i + 2),
VSTR(i + 3),
VSTR(i + 4),
VSTR(i + 5),
VSTR(i + 6));
break;
}
default: {
// do nothing
}
}
// Remove the last comma
if (click_count_ > 0) {
pos -= COMMA_STR_LEN;
}
return pos;
}
DEFINE_TO_YSON_KV(ObTimeGuard, OB_ID(click), common::ObArrayWrap<int32_t>(click_, click_count_));
////////////////////////////////////////////////////////////////////
// BandwidthThrottle
ObBandwidthThrottle::ObBandwidthThrottle()
: lock_(ObLatchIds::BANDWIDTH_THROTTLE_LOCK),
rate_(0),
next_avaliable_timestamp_(0),
unlimit_bytes_(0),
total_bytes_(0),
total_sleep_ms_(0),
last_printed_bytes_(0),
last_printed_sleep_ms_(0),
last_printed_ts_(0),
inited_(false)
{}
ObBandwidthThrottle::~ObBandwidthThrottle()
{}
int ObBandwidthThrottle::init(const int64_t rate, const char* comment)
{
int ret = OB_SUCCESS;
if (inited_) {
ret = OB_INIT_TWICE;
COMMON_LOG(WARN, "init throttle twice.", K(ret));
} else if (rate < 0 || OB_ISNULL(comment)) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "invalid arguments.", K(ret), K(rate), KP(comment));
} else {
ObSpinLockGuard guard(lock_);
rate_ = rate;
next_avaliable_timestamp_ = ObTimeUtility::current_time();
unlimit_bytes_ = 0;
last_printed_bytes_ = 0;
last_printed_ts_ = ObTimeUtility::current_time();
total_bytes_ = 0;
databuff_printf(comment_, OB_MAX_TASK_COMMENT_LENGTH, "%s", comment);
inited_ = true;
COMMON_LOG(INFO, "init bandwidth", K(rate_), K(comment_));
if (0 == rate_) {
LOG_ERROR("bandwidth throttle rate is zero, please make sure is the config right?");
}
}
return ret;
}
int ObBandwidthThrottle::set_rate(const int64_t rate)
{
int ret = OB_SUCCESS;
if (!inited_) {
ret = OB_NOT_INIT;
COMMON_LOG(WARN, "not inited", K(ret));
} else if (rate < 0) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "invalid args", K(ret), K(rate));
} else {
ObSpinLockGuard guard(lock_);
if (rate_ != rate) {
COMMON_LOG(INFO, "set bandwidth", "old rate", rate_, "new rate", rate);
rate_ = rate;
next_avaliable_timestamp_ = ObTimeUtility::current_time();
unlimit_bytes_ = 0;
if (0 == rate_) {
LOG_ERROR("bandwidth throttle rate is zero, please make sure is the config right?");
}
}
}
return ret;
}
void ObBandwidthThrottle::destroy()
{
ObSpinLockGuard guard(lock_);
COMMON_LOG(INFO, "destroy bandwidth throttle");
inited_ = false;
}
int ObBandwidthThrottle::limit_and_sleep(
const int64_t bytes, const int64_t last_active_time, const int64_t max_idle_time, int64_t& sleep_us)
{
int ret = OB_SUCCESS;
const int64_t PRINT_LOG_INTERVAL_MS = 1000; // 1s
int64_t avaliable_timestamp = 0;
sleep_us = 0;
if (!inited_) {
ret = OB_NOT_INIT;
COMMON_LOG(WARN, "throttle is not initialized.", K(ret));
} else if (OB_FAIL(cal_limit(bytes, avaliable_timestamp))) {
LOG_WARN("failed to cal limit", K(ret));
} else if (OB_FAIL(do_sleep(avaliable_timestamp, last_active_time, max_idle_time, sleep_us))) {
LOG_WARN("failed to do sleep", K(ret));
} else {
ObSpinLockGuard guard(lock_);
const int64_t cur_time = ObTimeUtility::current_time();
const int64_t print_interval_ms = (cur_time - last_printed_ts_) / 1000;
total_bytes_ += bytes;
total_sleep_ms_ += sleep_us / 1000;
if (print_interval_ms > PRINT_LOG_INTERVAL_MS) {
const int64_t copy_KB = (total_bytes_ - last_printed_bytes_) / 1024;
const int64_t speed_KB_per_s = copy_KB * 1000 / print_interval_ms;
const int64_t sleep_ms_sum = total_sleep_ms_ - last_printed_sleep_ms_;
COMMON_LOG(INFO,
"print band limit",
K_(comment),
K(copy_KB),
K(sleep_ms_sum),
K(speed_KB_per_s),
K_(total_sleep_ms),
K_(total_bytes),
"rate_KB/s",
rate_,
K(print_interval_ms));
last_printed_bytes_ = total_bytes_;
last_printed_sleep_ms_ = total_sleep_ms_;
last_printed_ts_ = cur_time;
}
}
return ret;
}
int ObBandwidthThrottle::cal_limit(const int64_t bytes, int64_t& avaliable_timestamp)
{
int ret = OB_SUCCESS;
avaliable_timestamp = 0;
ObSpinLockGuard guard(lock_);
if (!inited_) {
ret = OB_NOT_INIT;
COMMON_LOG(WARN, "throttle is not initialized.", K(ret));
} else if (bytes < 0 || bytes > 1024 * 1024 * 1024LL /* 1G */) {
ret = OB_INVALID_ARGUMENT;
COMMON_LOG(WARN, "invalid input bytes.", K(ret), K(bytes));
} else if (0 == rate_) {
avaliable_timestamp = INT64_MAX;
} else {
int64_t cur_time = ObTimeUtility::current_time();
unlimit_bytes_ += bytes;
if (unlimit_bytes_ > INT64_MAX / 1000 / 1000) {
COMMON_LOG(ERROR, "unlimit_bytes_ is too large, cannot limit it...", K(bytes), K(rate_), K(unlimit_bytes_));
next_avaliable_timestamp_ = cur_time;
unlimit_bytes_ = 0;
} else if (unlimit_bytes_ * 1000 * 1000 >=
200 * rate_) { // The minimum calculation unit is 200us, and the fragments smaller than the limit will
// be calculated next time
next_avaliable_timestamp_ = next_avaliable_timestamp_ + unlimit_bytes_ * 1000 * 1000 / rate_ + 1;
unlimit_bytes_ = 0;
if (cur_time > next_avaliable_timestamp_ + 200) { // Update the time stamp of the record when it exceeds 200us
next_avaliable_timestamp_ = cur_time - 200;
}
}
if (cur_time > next_avaliable_timestamp_) {
avaliable_timestamp = cur_time;
} else {
avaliable_timestamp = next_avaliable_timestamp_;
}
if (avaliable_timestamp - cur_time > UINT32_MAX) {
COMMON_LOG(ERROR,
"invalid limit time, maybe callers does not sleep properly after call this func",
K(ret),
K(bytes),
K(avaliable_timestamp),
K(next_avaliable_timestamp_),
K(unlimit_bytes_));
}
}
return ret;
}
int ObBandwidthThrottle::do_sleep(
const int64_t next_avaliable_ts, const int64_t last_active_time, const int64_t max_idle_time, int64_t& sleep_us)
{
int ret = OB_SUCCESS;
int64_t cur_time = ObTimeUtility::current_time();
int64_t max_wait_time =
cur_time - last_active_time > 0 ? max_idle_time - (cur_time - last_active_time) : max_idle_time;
int64_t sleep_time = next_avaliable_ts - cur_time;
int64_t real_sleep_time = std::min(sleep_time, max_wait_time);
sleep_us = 0;
if (real_sleep_time > 0 && real_sleep_time <= UINT32_MAX) {
COMMON_LOG(DEBUG, "do band limit sleep", K(max_wait_time), K(sleep_time), K(real_sleep_time), K(last_active_time));
sleep_us = real_sleep_time;
this_routine::usleep(static_cast<uint32_t>(real_sleep_time));
}
return ret;
}
ObInOutBandwidthThrottle::ObInOutBandwidthThrottle() : in_throttle_(), out_throttle_()
{}
ObInOutBandwidthThrottle::~ObInOutBandwidthThrottle()
{}
int ObInOutBandwidthThrottle::init(const int64_t rate)
{
int ret = OB_SUCCESS;
if (OB_FAIL(in_throttle_.init(rate, "in"))) {
COMMON_LOG(WARN, "failed to init in_throttle_", K(ret));
} else if (OB_FAIL(out_throttle_.init(rate, "out"))) {
COMMON_LOG(WARN, "failed to init out_throttle_", K(ret));
}
return ret;
}
int ObInOutBandwidthThrottle::set_rate(const int64_t rate)
{
int ret = OB_SUCCESS;
if (OB_FAIL(in_throttle_.set_rate(rate))) {
COMMON_LOG(WARN, "failed to set in_throttle_ rate", K(ret));
} else if (OB_FAIL(out_throttle_.set_rate(rate))) {
COMMON_LOG(WARN, "failed to set out_throttle_", K(ret));
}
return ret;
}
int ObInOutBandwidthThrottle::limit_in_and_sleep(
const int64_t bytes, const int64_t last_active_time, const int64_t max_idle_time)
{
int ret = OB_SUCCESS;
int64_t sleep_us = 0;
if (OB_FAIL(in_throttle_.limit_and_sleep(bytes, last_active_time, max_idle_time, sleep_us))) {
COMMON_LOG(WARN, "failed to limit in_throttle_", K(ret));
}
EVENT_ADD(BANDWIDTH_IN_THROTTLE, bytes);
EVENT_ADD(BANDWIDTH_IN_SLEEP_US, sleep_us);
return ret;
}
int ObInOutBandwidthThrottle::limit_out_and_sleep(
const int64_t bytes, const int64_t last_active_time, const int64_t max_idle_time)
{
int ret = OB_SUCCESS;
int64_t sleep_us = 0;
if (OB_FAIL(out_throttle_.limit_and_sleep(bytes, last_active_time, max_idle_time, sleep_us))) {
COMMON_LOG(WARN, "failed to limit out_throttle_", K(ret));
}
EVENT_ADD(BANDWIDTH_OUT_THROTTLE, bytes);
EVENT_ADD(BANDWIDTH_OUT_SLEEP_US, sleep_us);
return ret;
}
void ObInOutBandwidthThrottle::destroy()
{
in_throttle_.destroy();
out_throttle_.destroy();
}
char* ltoa10(int64_t val, char* dst, const bool is_signed)
{
char buffer[65];
uint64_t uval = (uint64_t)val;
if (is_signed) {
if (val < 0) {
*dst++ = '-';
/* Avoid integer overflow in (-val) for LONGLONG_MIN*/
uval = (uint64_t)0 - uval;
}
}
char* p = &buffer[sizeof(buffer) - 1];
*p = '\0';
int64_t new_val = (int64_t)(uval / 10);
*--p = (char)('0' + (uval - (uint64_t)new_val * 10));
val = new_val;
while (val != 0) {
new_val = val / 10;
*--p = (char)('0' + (val - new_val * 10));
val = new_val;
}
while ((*dst++ = *p++) != 0)
;
return dst - 1;
}
int long_to_str10(int64_t val, char* dst, const int64_t buf_len, const bool is_signed, int64_t& length)
{
int ret = OB_SUCCESS;
length = 0;
if (OB_ISNULL(dst) || buf_len < 2) { // at least one char and '\0'
ret = OB_INVALID_ARGUMENT;
LOG_WARN("Input invalid", K(dst), K(buf_len), K(ret));
} else {
char buffer[65];
uint64_t uval = (uint64_t)val;
if (is_signed) {
if (val < 0) {
*dst = '-';
++length;
/* Avoid integer overflow in (-val) for LONGLONG_MIN*/
uval = (uint64_t)0 - uval;
}
}
char* p = &buffer[sizeof(buffer) - 1];
*p = '\0';
int64_t new_val = (int64_t)(uval / 10);
*--p = (char)('0' + (uval - (uint64_t)new_val * 10));
val = new_val;
while (val != 0) {
new_val = val / 10;
*--p = (char)('0' + (val - new_val * 10));
val = new_val;
}
while (length < buf_len && (*(dst + length++) = *p++) != 0)
;
--length;
if (*(dst + length) != 0) {
ret = OB_SIZE_OVERFLOW;
}
}
return ret;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
const char* replica_type_to_str(const ObReplicaType& type)
{
const char* str = "";
switch (type) {
case REPLICA_TYPE_FULL:
str = "REPLICA_TYPE_FULL";
break;
case REPLICA_TYPE_BACKUP:
str = "REPLICA_TYPE_BACKUP";
break;
case REPLICA_TYPE_LOGONLY:
str = "REPLICA_TYPE_LOGONLY";
break;
case REPLICA_TYPE_READONLY:
str = "REPLICA_TYPE_READONLY";
break;
case REPLICA_TYPE_MEMONLY:
str = "REPLICA_TYPE_MEMONLY";
break;
default:
str = "REPLICA_TYPE_UNKNOWN";
}
return str;
}
void get_addr_by_proxy_sessid(const uint64_t session_id, ObAddr& addr)
{
const int32_t ip = static_cast<int32_t>((session_id >> 32) & 0xFFFFFFFF);
const int32_t port = static_cast<int32_t>((session_id >> 16) & 0xFFFF);
IGNORE_RETURN addr.set_ipv4_addr(ip, port);
}
int ob_strtoll(const char* str, char*& endptr, int64_t& res)
{
int ret = OB_SUCCESS;
res = 0;
if (OB_ISNULL(str)) {
ret = OB_INVALID_ARGUMENT;
} else {
res = strtoll(str, &endptr, 10);
if (INT64_MAX == res) {
ret = OB_SIZE_OVERFLOW;
}
}
return ret;
}
int ob_strtoull(const char* str, char*& endptr, uint64_t& res)
{
int ret = OB_SUCCESS;
res = 0;
int64_t tmp_res = 0;
if (OB_ISNULL(str)) {
ret = OB_INVALID_ARGUMENT;
} else {
tmp_res = strtoull(str, &endptr, 10);
if (UINT64_MAX == tmp_res) {
ret = OB_SIZE_OVERFLOW;
} else {
res = tmp_res;
}
}
return ret;
}
int ob_atoll(const char* str, int64_t& res)
{
int ret = OB_SUCCESS;
char* endptr = NULL;
int64_t val = 0;
if (OB_ISNULL(str)) {
ret = OB_INVALID_ARGUMENT;
} else if (OB_FAIL(ob_strtoll(str, endptr, val))) {
LIB_LOG(WARN, "failed to strtoll", K(ret), K(str));
} else if (str == endptr || OB_ISNULL(endptr) || OB_UNLIKELY('\0' != *endptr)) {
ret = OB_INVALID_ARGUMENT;
} else {
res = val;
}
return ret;
}
// ref: https://www.cnblogs.com/westfly/p/5139645.html
struct tm* ob_localtime(const time_t* unix_sec, struct tm* result)
{
static const int HOURS_IN_DAY = 24;
static const int MINUTES_IN_HOUR = 60;
static const int DAYS_FROM_UNIX_TIME = 2472632;
static const int DAYS_FROM_YEAR = 153;
static const int MAGIC_UNKONWN_FIRST = 146097;
static const int MAGIC_UNKONWN_SEC = 1461;
// use __timezone from glibc/time/tzset.c, default value is -480 for china
const int32_t tz_minutes = static_cast<int32_t>(__timezone / 60);
// only support time > 1970/1/1 8:0:0
if (OB_LIKELY(NULL != result) && OB_LIKELY(NULL != unix_sec) && OB_LIKELY(*unix_sec > 0)) {
result->tm_sec = static_cast<int>((*unix_sec) % MINUTES_IN_HOUR);
int tmp_i = static_cast<int>((*unix_sec) / MINUTES_IN_HOUR) - tz_minutes;
result->tm_min = tmp_i % MINUTES_IN_HOUR;
tmp_i /= MINUTES_IN_HOUR;
result->tm_hour = tmp_i % HOURS_IN_DAY;
result->tm_mday = tmp_i / HOURS_IN_DAY;
int tmp_a = result->tm_mday + DAYS_FROM_UNIX_TIME;
int tmp_b = (tmp_a * 4 + 3) / MAGIC_UNKONWN_FIRST;
int tmp_c = tmp_a - (tmp_b * MAGIC_UNKONWN_FIRST) / 4;
int tmp_d = ((tmp_c * 4 + 3) / MAGIC_UNKONWN_SEC);
int tmp_e = tmp_c - (tmp_d * MAGIC_UNKONWN_SEC) / 4;
int tmp_m = (5 * tmp_e + 2) / DAYS_FROM_YEAR;
result->tm_mday = tmp_e + 1 - (DAYS_FROM_YEAR * tmp_m + 2) / 5;
result->tm_mon = tmp_m + 2 - (tmp_m / 10) * 12;
result->tm_year = tmp_b * 100 + tmp_d - 6700 + (tmp_m / 10);
}
return result;
}
void ob_fast_localtime(
time_t& cached_unix_sec, struct tm& cached_localtime, const time_t& input_unix_sec, struct tm* output_localtime)
{
if (OB_LIKELY(NULL != output_localtime)) {
if (cached_unix_sec == input_unix_sec) {
*output_localtime = cached_localtime;
} else if (OB_UNLIKELY(0 == cached_unix_sec)) { // init
cached_unix_sec = input_unix_sec;
localtime_r(&input_unix_sec, output_localtime);
cached_localtime = *output_localtime;
;
} else {
cached_unix_sec = input_unix_sec;
cached_localtime = *ob_localtime(&input_unix_sec, output_localtime);
}
}
}
int is_dir_empty(const char* dirname, bool& is_empty)
{
int ret = OB_SUCCESS;
if (NULL == dirname) {
ret = OB_INVALID_ARGUMENT;
} else {
is_empty = true;
DIR* dir = opendir(dirname);
if (NULL == dir) {
if (ENOENT == errno) {
is_empty = true;
} else {
ret = OB_IO_ERROR;
LIB_LOG(ERROR, "opendir failed", K(ret), K(errno), KP(dirname));
}
} else {
while (OB_SUCC(ret)) {
struct dirent entry;
struct dirent* pentry = &entry;
memset(&entry, 0, sizeof(struct dirent));
if (0 != readdir_r(dir, pentry, &pentry)) {
ret = OB_IO_ERROR;
LIB_LOG(WARN, "readdir_r failed", K(ret), K(errno), KP(dirname));
} else if (NULL == pentry) {
ret = OB_ITER_END;
} else if (strcmp(".", pentry->d_name) == 0 || strcmp("..", pentry->d_name) == 0) {
continue;
} else {
is_empty = false;
break;
}
}
if (OB_ITER_END == ret) {
ret = OB_SUCCESS;
}
if (0 != closedir(dir)) {
ret = OB_IO_ERROR;
LIB_LOG(ERROR, "closedir failed", K(ret), K(errno), KP(dirname));
} else {
dir = NULL;
}
}
}
return ret;
}
} // end namespace common
} // end namespace oceanbase
Reference in New Issue View Git Blame Copy Permalink