482 lines
15 KiB
C
482 lines
15 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* polar_monitor_consensus.c
|
|
* display some information of polardb consensus
|
|
*
|
|
* Portions Copyright (c) 2021, Alibaba Group Holding Limited
|
|
* Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
*
|
|
* IDENTIFICATION
|
|
* contrib/polar_monitor/polar_monitor_consensus.c
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
#include "access/htup_details.h"
|
|
#include "catalog/pg_type.h"
|
|
#include "funcapi.h"
|
|
#include "miscadmin.h"
|
|
#include "polar_dma/polar_dma.h"
|
|
#include "polar_dma/consensus_slru.h"
|
|
#include "polar_dma/consensus_log.h"
|
|
#include "utils/builtins.h"
|
|
#include "utils/guc.h"
|
|
#include "utils/pg_lsn.h"
|
|
|
|
PG_FUNCTION_INFO_V1(polar_dma_get_member_status);
|
|
|
|
Datum
|
|
polar_dma_get_member_status(PG_FUNCTION_ARGS)
|
|
{
|
|
bool success;
|
|
TupleDesc tupdesc;
|
|
Datum *values;
|
|
bool *nulls;
|
|
ConsensusMemberInfo member_info;
|
|
|
|
if (!POLAR_ENABLE_DMA())
|
|
PG_RETURN_NULL();
|
|
|
|
success = ConsensusWaitForStatCollect(POLAR_DMA_STAT_MEMBER_INFO);
|
|
if (!success)
|
|
{
|
|
ereport(WARNING, (errmsg("consensus get stat fail")));
|
|
PG_RETURN_NULL();
|
|
}
|
|
ConsensusGetMemberInfo(&member_info);
|
|
|
|
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
|
|
elog(ERROR, "consensus get stat return type must be a row type");
|
|
|
|
values = palloc0(sizeof(Datum) * tupdesc->natts);
|
|
nulls = palloc0(sizeof(bool) * tupdesc->natts);
|
|
|
|
values[0] = UInt64GetDatum(member_info.serverId);
|
|
values[1] = UInt64GetDatum(member_info.currentTerm);
|
|
values[2] = UInt64GetDatum(member_info.currentLeader);
|
|
values[3] = UInt64GetDatum(member_info.commitIndex);
|
|
values[4] = UInt64GetDatum(member_info.lastLogTerm);
|
|
values[5] = UInt64GetDatum(member_info.lastLogIndex);
|
|
values[6] = Int32GetDatum(member_info.role);
|
|
values[7] = UInt64GetDatum(member_info.votedFor);
|
|
|
|
PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
|
|
}
|
|
|
|
PG_FUNCTION_INFO_V1(polar_dma_get_cluster_status);
|
|
|
|
Datum
|
|
polar_dma_get_cluster_status(PG_FUNCTION_ARGS)
|
|
{
|
|
#define PG_GET_CLUSTER_INFO_COLS 10
|
|
bool success;
|
|
ReturnSetInfo *clusters_info = (ReturnSetInfo *) fcinfo->resultinfo;
|
|
TupleDesc tupdesc;
|
|
Tuplestorestate *tupstore;
|
|
MemoryContext per_query_ctx;
|
|
MemoryContext oldcontext;
|
|
int cno;
|
|
ConsensusClusterInfo clusterInfo[POLAR_DMA_MAX_NODES_NUM];
|
|
int numCluster;
|
|
|
|
if (!POLAR_ENABLE_DMA())
|
|
PG_RETURN_NULL();
|
|
|
|
success = ConsensusWaitForStatCollect(POLAR_DMA_STAT_CLUSTER_INFO);
|
|
if (!success)
|
|
{
|
|
ereport(WARNING, (errmsg("consensus get stat fail")));
|
|
PG_RETURN_NULL();
|
|
}
|
|
numCluster = ConsensusGetClusterInfo(clusterInfo);
|
|
|
|
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
|
|
elog(ERROR, "consensus get stat return type must be a row type");
|
|
|
|
per_query_ctx = clusters_info->econtext->ecxt_per_query_memory;
|
|
oldcontext = MemoryContextSwitchTo(per_query_ctx);
|
|
|
|
tupstore = tuplestore_begin_heap(true, false, work_mem);
|
|
clusters_info->returnMode = SFRM_Materialize;
|
|
clusters_info->setResult = tupstore;
|
|
clusters_info->setDesc = tupdesc;
|
|
|
|
MemoryContextSwitchTo(oldcontext);
|
|
|
|
for (cno = 0; cno < numCluster && cno < POLAR_DMA_MAX_NODES_NUM; cno++)
|
|
{
|
|
Datum values[PG_GET_CLUSTER_INFO_COLS];
|
|
bool nulls[PG_GET_CLUSTER_INFO_COLS];
|
|
int i;
|
|
ConsensusClusterInfo cinfo = clusterInfo[cno];
|
|
|
|
memset(nulls, 0, sizeof(nulls));
|
|
|
|
i = 0;
|
|
values[i++] = UInt64GetDatum(cinfo.serverId);
|
|
values[i++] = CStringGetTextDatum(cinfo.ipPort);
|
|
values[i++] = UInt64GetDatum(cinfo.matchIndex);
|
|
values[i++] = UInt64GetDatum(cinfo.nextIndex);
|
|
values[i++] = Int32GetDatum(cinfo.role);
|
|
values[i++] = BoolGetDatum(cinfo.hasVoted != 0 ? true : false);
|
|
values[i++] = BoolGetDatum(cinfo.forceSync);
|
|
values[i++] = UInt32GetDatum(cinfo.electionWeight);
|
|
values[i++] = UInt64GetDatum(cinfo.learnerSource);
|
|
values[i++] = BoolGetDatum(cinfo.pipelining);
|
|
|
|
tuplestore_putvalues(tupstore, tupdesc, values, nulls);
|
|
}
|
|
|
|
tuplestore_donestoring(tupstore);
|
|
|
|
return (Datum) 0;
|
|
}
|
|
|
|
PG_FUNCTION_INFO_V1(polar_dma_get_msg_stats);
|
|
|
|
Datum
|
|
polar_dma_get_msg_stats(PG_FUNCTION_ARGS)
|
|
{
|
|
bool success;
|
|
TupleDesc tupdesc;
|
|
Datum *values;
|
|
bool *nulls;
|
|
ConsensusStatsInfo stats_info;
|
|
int i;
|
|
|
|
if (!POLAR_ENABLE_DMA())
|
|
PG_RETURN_NULL();
|
|
|
|
success = ConsensusWaitForStatCollect(POLAR_DMA_STATS_INFO);
|
|
if (!success)
|
|
{
|
|
ereport(WARNING, (errmsg("consensus get stat fail")));
|
|
PG_RETURN_NULL();
|
|
}
|
|
ConsensusGetStatsInfo(&stats_info);
|
|
|
|
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
|
|
elog(ERROR, "consensus get stat return type must be a row type");
|
|
|
|
values = palloc0(sizeof(Datum) * tupdesc->natts);
|
|
nulls = palloc0(sizeof(bool) * tupdesc->natts);
|
|
|
|
i = 0;
|
|
values[i++] = UInt64GetDatum(stats_info.serverId);
|
|
values[i++] = UInt64GetDatum(stats_info.countMsgAppendLog);
|
|
values[i++] = UInt64GetDatum(stats_info.countMsgRequestVote);
|
|
values[i++] = UInt64GetDatum(stats_info.countHeartbeat);
|
|
values[i++] = UInt64GetDatum(stats_info.countOnMsgAppendLog);
|
|
values[i++] = UInt64GetDatum(stats_info.countOnMsgRequestVote);
|
|
values[i++] = UInt64GetDatum(stats_info.countOnHeartbeat);
|
|
values[i++] = UInt64GetDatum(stats_info.countReplicateLog);
|
|
|
|
PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
|
|
}
|
|
|
|
PG_FUNCTION_INFO_V1(polar_dma_get_consensus_status);
|
|
|
|
Datum
|
|
polar_dma_get_consensus_status(PG_FUNCTION_ARGS)
|
|
{
|
|
TupleDesc tupdesc;
|
|
Datum *values;
|
|
bool *nulls;
|
|
ConsensusStatus status_info;
|
|
int i;
|
|
|
|
if (!POLAR_ENABLE_DMA())
|
|
PG_RETURN_NULL();
|
|
|
|
ConsensusGetStatus(&status_info);
|
|
|
|
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
|
|
elog(ERROR, "consensus get stat return type must be a row type");
|
|
|
|
values = palloc0(sizeof(Datum) * tupdesc->natts);
|
|
nulls = palloc0(sizeof(bool) * tupdesc->natts);
|
|
|
|
i = 0;
|
|
values[i++] = UInt32GetDatum(status_info.current_state);
|
|
values[i++] = UInt64GetDatum(status_info.term);
|
|
values[i++] = UInt64GetDatum(status_info.log_term);
|
|
values[i++] = UInt64GetDatum(status_info.xlog_term);
|
|
values[i++] = UInt64GetDatum(status_info.leader_id);
|
|
values[i++] = LSNGetDatum(status_info.sync_rqst_lsn);
|
|
values[i++] = UInt32GetDatum(status_info.synced_tli);
|
|
values[i++] = LSNGetDatum(status_info.synced_lsn);
|
|
values[i++] = LSNGetDatum(status_info.purge_lsn);
|
|
values[i++] = UInt64GetDatum(status_info.commit_index);
|
|
values[i++] = LSNGetDatum(status_info.flushed_lsn);
|
|
values[i++] = UInt32GetDatum(status_info.flushed_tli);
|
|
values[i++] = LSNGetDatum(status_info.appended_lsn);
|
|
values[i++] = UInt32GetDatum(status_info.commit_queue_length);
|
|
values[i++] = UInt32GetDatum(status_info.stats_queue_length);
|
|
|
|
PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
|
|
}
|
|
|
|
PG_FUNCTION_INFO_V1(polar_dma_get_log_status);
|
|
|
|
Datum
|
|
polar_dma_get_log_status(PG_FUNCTION_ARGS)
|
|
{
|
|
TupleDesc tupdesc;
|
|
Datum *values;
|
|
bool *nulls;
|
|
ConsensusLogStatus status_info;
|
|
int i;
|
|
|
|
if (!POLAR_ENABLE_DMA())
|
|
PG_RETURN_NULL();
|
|
|
|
ConsensusLogGetStatus(&status_info);
|
|
|
|
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
|
|
elog(ERROR, "consensus get stat return type must be a row type");
|
|
|
|
values = palloc0(sizeof(Datum) * tupdesc->natts);
|
|
nulls = palloc0(sizeof(bool) * tupdesc->natts);
|
|
|
|
i = 0;
|
|
values[i++] = UInt64GetDatum(status_info.current_term);
|
|
values[i++] = UInt64GetDatum(status_info.current_index);
|
|
values[i++] = UInt64GetDatum(status_info.sync_index);
|
|
values[i++] = LSNGetDatum(status_info.last_write_lsn);
|
|
values[i++] = UInt64GetDatum(status_info.last_write_timeline);
|
|
values[i++] = UInt64GetDatum(status_info.last_append_term);
|
|
values[i++] = UInt64GetDatum(status_info.next_append_term);
|
|
values[i++] = UInt64GetDatum(status_info.variable_length_log_next_offset);
|
|
values[i++] = BoolGetDatum(status_info.disable_purge);
|
|
|
|
PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
|
|
}
|
|
|
|
PG_FUNCTION_INFO_V1(polar_dma_get_meta_status);
|
|
|
|
Datum
|
|
polar_dma_get_meta_status(PG_FUNCTION_ARGS)
|
|
{
|
|
TupleDesc tupdesc;
|
|
Datum *values;
|
|
bool *nulls;
|
|
ConsensusMetaStatus status_info;
|
|
int member_info_size, learner_info_size;
|
|
char *member_info_ptr, *learner_info_ptr;
|
|
char member_info_str[MEMBER_INFO_MAX_LENGTH],
|
|
learner_info_str[MEMBER_INFO_MAX_LENGTH];
|
|
int i;
|
|
|
|
if (!POLAR_ENABLE_DMA())
|
|
PG_RETURN_NULL();
|
|
|
|
ConsensusMetaGetStatus(&status_info);
|
|
|
|
member_info_size = ConsensusMetaGetMemberInfoFromArray(&member_info_ptr);
|
|
if (member_info_size > 0)
|
|
{
|
|
member_info_size = member_info_size > MEMBER_INFO_MAX_LENGTH ?
|
|
MEMBER_INFO_MAX_LENGTH : member_info_size;
|
|
strncpy(member_info_str, member_info_ptr, member_info_size-1);
|
|
free(member_info_ptr);
|
|
member_info_str[member_info_size-1] = '\0';
|
|
}
|
|
|
|
learner_info_size = ConsensusMetaGetLearnerInfoFromArray(&learner_info_ptr);
|
|
if (learner_info_size > 0)
|
|
{
|
|
learner_info_size = learner_info_size > MEMBER_INFO_MAX_LENGTH ?
|
|
MEMBER_INFO_MAX_LENGTH : learner_info_size;
|
|
strncpy(learner_info_str, learner_info_ptr, learner_info_size-1);
|
|
free(learner_info_ptr);
|
|
learner_info_str[learner_info_size-1] = '\0';
|
|
}
|
|
|
|
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
|
|
elog(ERROR, "consensus get stat return type must be a row type");
|
|
|
|
values = palloc0(sizeof(Datum) * tupdesc->natts);
|
|
nulls = palloc0(sizeof(bool) * tupdesc->natts);
|
|
|
|
i = 0;
|
|
values[i++] = UInt64GetDatum(status_info.current_term);
|
|
values[i++] = UInt64GetDatum(status_info.vote_for);
|
|
values[i++] = UInt64GetDatum(status_info.last_leader_term);
|
|
values[i++] = UInt64GetDatum(status_info.last_leader_log_index);
|
|
values[i++] = UInt64GetDatum(status_info.scan_index);
|
|
values[i++] = UInt64GetDatum(status_info.cluster_id);
|
|
values[i++] = UInt64GetDatum(status_info.commit_index);
|
|
values[i++] = UInt64GetDatum(status_info.purge_index);
|
|
|
|
if (member_info_size > 0)
|
|
values[i++] = CStringGetTextDatum(member_info_str);
|
|
else
|
|
nulls[i++] = true;
|
|
|
|
if (learner_info_size > 0)
|
|
values[i++] = CStringGetTextDatum(learner_info_str);
|
|
else
|
|
nulls[i++] = true;
|
|
|
|
PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
|
|
}
|
|
|
|
PG_FUNCTION_INFO_V1(polar_dma_get_consensus_stats);
|
|
|
|
Datum
|
|
polar_dma_get_consensus_stats(PG_FUNCTION_ARGS)
|
|
{
|
|
TupleDesc tupdesc;
|
|
Datum *values;
|
|
bool *nulls;
|
|
ConsensusStats stats_info;
|
|
int i;
|
|
|
|
if (!POLAR_ENABLE_DMA())
|
|
PG_RETURN_NULL();
|
|
|
|
ConsensusGetStats(&stats_info);
|
|
|
|
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
|
|
elog(ERROR, "consensus get stat return type must be a row type");
|
|
|
|
values = palloc0(sizeof(Datum) * tupdesc->natts);
|
|
nulls = palloc0(sizeof(bool) * tupdesc->natts);
|
|
|
|
i = 0;
|
|
values[i++] = UInt64GetDatum(stats_info.transit_waits);
|
|
values[i++] = UInt64GetDatum(stats_info.xlog_transit_waits);
|
|
values[i++] = UInt64GetDatum(stats_info.xlog_flush_waits);
|
|
values[i++] = UInt64GetDatum(stats_info.consensus_appends);
|
|
values[i++] = UInt64GetDatum(stats_info.consensus_wakeups);
|
|
values[i++] = UInt64GetDatum(stats_info.consensus_backend_wakeups);
|
|
values[i++] = UInt64GetDatum(stats_info.consensus_commit_waits);
|
|
values[i++] = UInt64GetDatum(stats_info.consensus_commit_wait_time);
|
|
|
|
PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
|
|
}
|
|
|
|
PG_FUNCTION_INFO_V1(polar_dma_get_log_stats);
|
|
|
|
Datum
|
|
polar_dma_get_log_stats(PG_FUNCTION_ARGS)
|
|
{
|
|
TupleDesc tupdesc;
|
|
Datum *values;
|
|
bool *nulls;
|
|
ConsensusLogStats stats_info;
|
|
int i;
|
|
|
|
if (!POLAR_ENABLE_DMA())
|
|
PG_RETURN_NULL();
|
|
|
|
ConsensusLogGetStats(&stats_info);
|
|
|
|
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
|
|
elog(ERROR, "consensus get stat return type must be a row type");
|
|
|
|
values = palloc0(sizeof(Datum) * tupdesc->natts);
|
|
nulls = palloc0(sizeof(bool) * tupdesc->natts);
|
|
|
|
i = 0;
|
|
values[i++] = UInt64GetDatum(stats_info.log_reads);
|
|
values[i++] = UInt64GetDatum(stats_info.variable_log_reads);
|
|
values[i++] = UInt64GetDatum(stats_info.log_appends);
|
|
values[i++] = UInt64GetDatum(stats_info.variable_log_appends);
|
|
values[i++] = UInt64GetDatum(stats_info.log_flushes);
|
|
values[i++] = UInt64GetDatum(stats_info.meta_flushes);
|
|
values[i++] = UInt64GetDatum(stats_info.xlog_flush_tries);
|
|
values[i++] = UInt64GetDatum(stats_info.xlog_flush_failed_tries);
|
|
values[i++] = UInt64GetDatum(stats_info.xlog_transit_waits);
|
|
|
|
PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls)));
|
|
}
|
|
|
|
PG_FUNCTION_INFO_V1(polar_dma_get_slru_stats);
|
|
|
|
Datum
|
|
polar_dma_get_slru_stats(PG_FUNCTION_ARGS)
|
|
{
|
|
#define SLRU_STAT_COLS 20
|
|
int i = 0;
|
|
ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
|
|
TupleDesc tupdesc;
|
|
Tuplestorestate *tupstore;
|
|
MemoryContext per_query_ctx;
|
|
MemoryContext oldcontext;
|
|
|
|
if (!POLAR_ENABLE_DMA())
|
|
PG_RETURN_NULL();
|
|
|
|
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
|
|
elog(ERROR, "consensus get stat return type must be a row type");
|
|
|
|
per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
|
|
oldcontext = MemoryContextSwitchTo(per_query_ctx);
|
|
|
|
tupstore = tuplestore_begin_heap(true, false, work_mem);
|
|
rsinfo->returnMode = SFRM_Materialize;
|
|
rsinfo->setResult = tupstore;
|
|
rsinfo->setDesc = tupdesc;
|
|
|
|
MemoryContextSwitchTo(oldcontext);
|
|
|
|
for (i = 0; i < n_consensus_slru_stats; i++)
|
|
{
|
|
const consensus_slru_stat *stat = consensus_slru_stats[i];
|
|
Datum values[SLRU_STAT_COLS];
|
|
bool nulls[SLRU_STAT_COLS];
|
|
int j = 0;
|
|
|
|
if (stat == NULL)
|
|
continue;
|
|
|
|
MemSet(nulls, 0, sizeof(bool) * SLRU_STAT_COLS);
|
|
|
|
values[j++] = CStringGetTextDatum(stat->name);
|
|
values[j++] = UInt32GetDatum(stat->n_slots);
|
|
values[j++] = UInt32GetDatum(stat->n_page_status_stat[SLRU_PAGE_VALID]);
|
|
values[j++] = UInt32GetDatum(stat->n_page_status_stat[SLRU_PAGE_EMPTY]);
|
|
values[j++] = UInt32GetDatum(stat->n_page_status_stat[SLRU_PAGE_READ_IN_PROGRESS]);
|
|
values[j++] = UInt32GetDatum(stat->n_page_status_stat[SLRU_PAGE_WRITE_IN_PROGRESS]);
|
|
values[j++] = UInt32GetDatum(stat->n_wait_reading_count);
|
|
values[j++] = UInt32GetDatum(stat->n_wait_writing_count);
|
|
values[j++] = UInt64GetDatum(stat->n_slru_read_count);
|
|
values[j++] = UInt64GetDatum(stat->n_slru_read_only_count);
|
|
values[j++] = UInt64GetDatum(stat->n_slru_read_upgrade_count);
|
|
values[j++] = UInt64GetDatum(stat->n_victim_count);
|
|
values[j++] = UInt64GetDatum(stat->n_victim_write_count);
|
|
values[j++] = UInt64GetDatum(stat->n_slru_write_count);
|
|
values[j++] = UInt64GetDatum(stat->n_slru_zero_count);
|
|
values[j++] = UInt64GetDatum(stat->n_slru_flush_count);
|
|
values[j++] = UInt64GetDatum(stat->n_slru_truncate_forward_count);
|
|
values[j++] = UInt64GetDatum(stat->n_slru_truncate_backward_count);
|
|
values[j++] = UInt64GetDatum(stat->n_storage_read_count);
|
|
values[j++] = UInt64GetDatum(stat->n_storage_write_count);
|
|
|
|
tuplestore_putvalues(tupstore, tupdesc, values, nulls);
|
|
}
|
|
/* clean up and return the tuplestore */
|
|
tuplestore_donestoring(tupstore);
|
|
|
|
return (Datum) 0;
|
|
}
|
|
|
|
PG_FUNCTION_INFO_V1(polar_dma_wal_committed_lsn);
|
|
|
|
/*
|
|
* Report the current WAL consensus commit location
|
|
*/
|
|
Datum
|
|
polar_dma_wal_committed_lsn(PG_FUNCTION_ARGS)
|
|
{
|
|
XLogRecPtr current_recptr;
|
|
|
|
current_recptr = ConsensusGetSyncedLSN();
|
|
|
|
PG_RETURN_LSN(current_recptr);
|
|
}
|