const std::string WiredTigerEngine::Stats()
{
std::string info;
int major_v, minor_v, patch;
(void) wiredtiger_version(&major_v, &minor_v, &patch);
info.append("WiredTiger version:").append(stringfromll(major_v)).append(".").append(stringfromll(minor_v)).append(
".").append(stringfromll(patch)).append("\r\n");
info.append("WiredTiger Init Options:").append(m_cfg.init_options).append("\r\n");
info.append("WiredTiger Table Init Options:").append(m_cfg.init_table_options).append("\r\n");
ContextHolder& holder = m_context.GetValue();
WT_SESSION* session = holder.session;
if (NULL == session)
{
return info;
}
WT_CURSOR *cursor;
int ret;
/*! [statistics database function] */
if ((ret = session->open_cursor(session, "statistics:", NULL, NULL, &cursor)) == 0)
{
print_cursor(cursor, info);
cursor->close(cursor);
}
if ((ret = session->open_cursor(session, "statistics:table:ardb", NULL, NULL, &cursor)) == 0)
{
print_cursor(cursor, info);
cursor->close(cursor);
}
return info;
}
const std::string LevelDBEngine::Stats()
{
std::string str, version_info;
version_info.append("LevelDB version:").append(stringfromll(leveldb::kMajorVersion)).append(".").append(
stringfromll(leveldb::kMinorVersion)).append("\r\n");
m_db->GetProperty("leveldb.stats", &str);
return version_info + str;
}
void PerconaFTEngine::Stats(Context& ctx, std::string& str)
{
str.append("perconaft_version:").append(stringfromll(DB_VERSION_MAJOR)).append(".").append(stringfromll(DB_VERSION_MINOR)).append(".").append(
stringfromll(DB_VERSION_PATCH)).append("\r\n");
DataArray nss;
ListNameSpaces(ctx, nss);
PerconaFTLocalContext& local_ctx = g_local_ctx.GetValue();
for (size_t i = 0; i < nss.size(); i++)
{
DB* db = GetFTDB(ctx, nss[i], false);
if (NULL == db)
continue;
str.append("\r\nDB[").append(nss[i].AsString()).append("] Stats:\r\n");
DB_BTREE_STAT64 st;
memset(&st, 0, sizeof(st));
db->stat64(db, local_ctx.transc.Peek(), &st);
str.append("bt_nkeys:").append(stringfromll(st.bt_nkeys)).append("\r\n");
str.append("bt_ndata:").append(stringfromll(st.bt_ndata)).append("\r\n");
str.append("bt_fsize:").append(stringfromll(st.bt_fsize)).append("\r\n");
str.append("bt_dsize:").append(stringfromll(st.bt_dsize)).append("\r\n");
str.append("bt_create_time_sec:").append(stringfromll(st.bt_create_time_sec)).append("\r\n");
str.append("bt_modify_time_sec:").append(stringfromll(st.bt_modify_time_sec)).append("\r\n");
str.append("bt_verify_time_sec:").append(stringfromll(st.bt_verify_time_sec)).append("\r\n");
}
}
const std::string& Statistics::PrintStat(std::string& str)
{
std::string substat;
uint64 total_connections_received = 0;
uint64 total_commands_processed = 0;
uint64 instantaneous_ops_per_sec = 0;
uint64 refused_client = 0;
ServerStatisticsTable::iterator it = m_server_stats.begin();
while (it != m_server_stats.end())
{
ServerStatistics& st = it->second;
if (st.stat_numcommands > 0)
{
total_connections_received += st.connections_received;
total_commands_processed += st.stat_numcommands;
instantaneous_ops_per_sec += st.GetOperationsPerSecond();
substat.append(it->first).append(": ");
substat.append("connections_received=").append(stringfromll(st.connections_received)).append(" ");
substat.append("commands_processed=").append(stringfromll(st.stat_numcommands)).append(" ");
substat.append("ops_per_sec=").append(stringfromll(st.GetOperationsPerSecond())).append(
"\n");
substat.append("refused_client=").append(stringfromll(st.refused_connections)).append(
"\n");
}
it++;
}
str.append("total_connections_received:").append(stringfromll(total_connections_received)).append("\n");
str.append("total_commands_processed:").append(stringfromll(total_commands_processed)).append("\n");
str.append("expired_keys:").append(stringfromll(stat_expiredkeys)).append("\n");
str.append("instantaneous_ops_per_sec:").append(stringfromll(instantaneous_ops_per_sec)).append("\n");
str.append("refused_client:").append(stringfromll(refused_client)).append("\n");
str.append(substat);
return str;
}
void Master::PrintSlaves(std::string& str)
{
uint32 i = 0;
char buffer[1024];
SlaveConnTable::iterator it = m_slave_table.begin();
while (it != m_slave_table.end())
{
const char* state = "ok";
SlaveConnection* slave = it->second;
switch (slave->state)
{
case SLAVE_STATE_WAITING_DUMP_DATA:
{
state = "wait_bgsave";
break;
}
case SLAVE_STATE_SYNING_DUMP_DATA:
{
state = "send_bulk";
break;
}
case SLAVE_STATE_SYNING_CACHE_DATA:
case SLAVE_STATE_SYNCED:
{
state = "online";
break;
}
default:
{
state = "invalid state";
break;
}
}
Address* remote = const_cast<Address*>(slave->conn->GetRemoteAddress());
std::string address;
if (InstanceOf<SocketUnixAddress>(remote).OK)
{
SocketUnixAddress* un = (SocketUnixAddress*) remote;
address = "unix_socket=";
address += un->GetPath();
} else if (InstanceOf<SocketHostAddress>(remote).OK)
{
SocketHostAddress* un = (SocketHostAddress*) remote;
address = "ip=";
address += un->GetHost();
address += ",port=";
address += stringfromll(slave->port);
}
uint32 lag = time(NULL) - slave->acktime;
sprintf(buffer, "slave%u:%s,state=%s,"
"offset=%"PRId64",lag=%u\r\n", i, address.c_str(), state, slave->sync_offset, lag);
it++;
i++;
str.append(buffer);
}
}
std::string ascii_codes(const std::string& str)
{
std::string ret;
for(uint32 i = 0 ; i < str.size(); i++)
{
unsigned char c = (unsigned char)str.at(i);
ret.append(stringfromll((int64)c)).append(" ");
}
return ret;
}
const std::string LMDBEngine::Stats()
{
MDB_stat stat;
MDB_txn* txn;
int rc = mdb_txn_begin(m_env, NULL, 0, &txn);
if (0 == rc)
{
mdb_stat(txn, m_dbi, &stat);
mdb_txn_commit(txn);
std::string stat_info;
stat_info.append("lmdb version:").append(mdb_version(NULL, NULL, NULL)).append("\r\n");
stat_info.append("db page size:").append(stringfromll(stat.ms_psize)).append("\r\n");
stat_info.append("b-tree depath:").append(stringfromll(stat.ms_depth)).append("\r\n");
stat_info.append("branch pages:").append(stringfromll(stat.ms_branch_pages)).append("\r\n");
stat_info.append("leaf pages:").append(stringfromll(stat.ms_leaf_pages)).append("\r\n");
stat_info.append("overflow oages:").append(stringfromll(stat.ms_overflow_pages)).append("\r\n");
stat_info.append("data items:").append(stringfromll(stat.ms_entries));
return stat_info;
}
else
{
return "Failed to get lmdb's stats";
}
}
std::string GetAddress()
{
std::string address;
Address* remote = const_cast<Address*>(conn->GetRemoteAddress());
if (InstanceOf<SocketHostAddress>(remote).OK)
{
SocketHostAddress* un = (SocketHostAddress*) remote;
address = "ip=";
address += un->GetHost();
address += ",port=";
address += stringfromll(port);
}
return address;
}
int Ardb::Scan(Context& ctx, RedisCommandFrame& cmd)
{
StringArray keys;
std::string pattern;
uint32 limit = 10000; //return max 10000 keys one time
if (cmd.GetArguments().size() > 1)
{
for (uint32 i = 1; i < cmd.GetArguments().size(); i++)
{
if (!strcasecmp(cmd.GetArguments()[i].c_str(), "count"))
{
if (i + 1 >= cmd.GetArguments().size() || !string_touint32(cmd.GetArguments()[i + 1], limit))
{
fill_error_reply(ctx.reply, "value is not an integer or out of range");
return 0;
}
i++;
}
else if (!strcasecmp(cmd.GetArguments()[i].c_str(), "match"))
{
if (i + 1 >= cmd.GetArguments().size())
{
fill_error_reply(ctx.reply, "'MATCH' need one args followed");
return 0;
}
pattern = cmd.GetArguments()[i + 1];
i++;
}
else
{
fill_error_reply(ctx.reply, "Syntax error, try scan 0 ");
return 0;
}
}
}
RedisReply& r1 = ctx.reply.AddMember();
RedisReply& r2 = ctx.reply.AddMember();
r2.type = REDIS_REPLY_ARRAY;
KeyObject from;
from.db = ctx.currentDB;
from.type = KEY_META;
const std::string& cursor = cmd.GetArguments()[0];
std::string scan_start_cursor;
if (cmd.GetArguments()[0] != "0")
{
if (m_cfg.scan_redis_compatible)
{
FindElementByRedisCursor(cursor, scan_start_cursor);
}
from.key = scan_start_cursor;
}
Iterator* iter = IteratorKeyValue(from, false);
bool reachend = false;
std::string tmpkey;
while (NULL != iter && iter->Valid())
{
KeyObject kk;
if (!decode_key(iter->Key(), kk) || kk.db != ctx.currentDB || kk.type != KEY_META)
{
reachend = true;
break;
}
tmpkey.clear();
tmpkey.assign(kk.key.data(), kk.key.size());
if (r2.MemberSize() >= limit)
{
break;
}
if ((pattern.empty()
|| stringmatchlen(pattern.c_str(), pattern.size(), tmpkey.c_str(), tmpkey.size(), 0) == 1))
{
RedisReply& rr1 = r2.AddMember();
fill_str_reply(rr1, tmpkey);
}
iter->Next();
}
if (reachend || !iter->Valid())
{
fill_str_reply(r1, "0");
}
else
{
if (m_cfg.scan_redis_compatible)
{
uint64 newcursor = GetNewRedisCursor(tmpkey);
fill_str_reply(r1, stringfromll(newcursor));
}
else
{
fill_str_reply(r1, tmpkey);
}
}
DELETE(iter);
return 0;
}
int Cluster::CreateZookeeperPath()
{
char hostname[1024]; //_SC_HOST_NAME_MAX = 255 default,
int hostname_len = gethostname(hostname, sizeof(hostname));
std::string host_name(hostname, hostname_len);
cJSON* content = cJSON_CreateObject();
cJSON_AddItemToObject(content, "uptime", cJSON_CreateNumber(time(NULL)));
cJSON_AddItemToObject(content, "addr", cJSON_CreateString(host_name.c_str()));
char* jsonstr = cJSON_Print(content);
cJSON_Delete(content);
std::string zk_path = "/" + g_db->GetConf().cluster_name + "/servers/" + host_name + ":" + stringfromll(g_db->GetConf().PrimaryPort());
int err = zoo_create(m_zk, zk_path.c_str(), jsonstr, strlen(jsonstr), &m_zk_acl, ZOO_EPHEMERAL, "", 0);
free(jsonstr);
if (0 == err)
{
m_state = ZK_STATE_FETCH_TOPO;
}
else
{
WARN_LOG("Failed to create path or reason:%s", zerror(err));
}
return err;
}
