pgpool如何对数据库节点进行状态检查及相关数据结构描述

/*
 * configuration parameters
 */
typedef struct {
    char *listen_addresses;            /* hostnames/IP addresses to listen on */
    int    port;                        /* port # to bind */
    char *pcp_listen_addresses;        /* PCP listen address to listen on */
    int pcp_port;                    /* PCP port # to bind */
    char *socket_dir;                /* pgpool socket directory */
    char *wd_ipc_socket_dir;        /* watchdog command IPC socket directory */
    char *pcp_socket_dir;            /* PCP socket directory */
    int    num_init_children;            /* # of children initially pre-forked */
    int    listen_backlog_multiplier;    /* determines the size of the connection queue */
    bool serialize_accept;            /* if non 0, serialize call to accept() to avoid thundering herd problem */
    int    child_life_time;            /* if idle for this seconds, child exits */
    int    connection_life_time;        /* if idle for this seconds, connection closes */
    int    child_max_connections;        /* if max_connections received, child exits */
    int client_idle_limit;            /* If client_idle_limit is n (n > 0), the client is forced to be
                                     *disconnected after n seconds idle */
    int authentication_timeout;        /* maximum time in seconds to complete client authentication */
    int    max_pool;                    /* max # of connection pool per child */
    char *logdir;                    /* logging directory */
    char *log_destination;            /* log destination: stderr or syslog */
    int syslog_facility;            /* syslog facility: LOCAL0, LOCAL1, ... */
    char *syslog_ident;                /* syslog ident string: pgpool */
    char *pid_file_name;            /* pid file name */
    bool replication_mode;            /* replication mode */
    bool log_connections;            /* logs incoming connections */
    bool log_hostname;                /* resolve hostname */
    bool enable_pool_hba;            /* enables pool_hba.conf file authentication */
    char *pool_passwd;                /* pool_passwd file name. "" disables pool_passwd */
    bool load_balance_mode;            /* load balance mode */

bool replication_stop_on_mismatch;    /* if there's a data mismatch between master and secondary
                                         * start degeneration to stop replication mode
                                         */
    bool failover_if_affected_tuples_mismatch;    /* If there's a disagreement with the number of affected tuples in
                                                 * UPDATE/DELETE, then degenerate the node which is most likely
                                                 * "minority".  # If false, just abort the transaction to keep the
                                                 * consistency.
                                                 */    
    bool replicate_select;            /* replicate SELECT statement when load balancing is disabled. */
    char **reset_query_list;        /* comma separated list of queries to be issued at the end of session */
    char **white_function_list;        /* list of functions with no side effects */
    char **black_function_list;        /* list of functions with side effects */
    char *log_line_prefix;            /* printf-style string to output at beginning of each log line */
    int log_error_verbosity;        /* controls how much detail about error should be emitted */
    int client_min_messages;        /* controls which message should be sent to client */
    int log_min_messages;            /* controls which message should be emitted to server log */
    bool master_slave_mode;            /* operate in master/slave mode */
    MasterSlaveSubModes master_slave_sub_mode;        /* either "slony" or "stream" */
    int64 delay_threshold;            /* If the standby server delays more than delay_threshold,
                                     * any query goes to the primary only. The unit is in bytes.
                                     * 0 disables the check. Default is 0.
                                     * Note that health_check_period required to be greater than 0
                                     * to enable the functionality.
                                     */
    LogStandbyDelayModes log_standby_delay;    /* how to log standby lag */
    bool connection_cache;                    /* cache connection pool? */
    int health_check_timeout;                /* health check timeout */
    int health_check_period;                /* health check period */
    char *health_check_user;                /* PostgreSQL user name for health check */
    char *health_check_password;            /* password for health check username */
    char *health_check_database;            /* database name for health check username */
    int health_check_max_retries;            /* health check max retries */
    int health_check_retry_delay;            /* amount of time to wait between retries */
    int connect_timeout;                    /* timeout value before giving up connecting to backend */
    int sr_check_period;                    /* streaming replication check period */
    char *sr_check_user;                    /* PostgreSQL user name for streaming replication check */
    char *sr_check_password;                /* password for sr_check_user */
    char *sr_check_database;                /* PostgreSQL database name for streaming replication check */
    char *failover_command;                    /* execute command when failover happens */
    char *follow_master_command;            /* execute command when failover is ended */
    char *failback_command;                    /* execute command when failback happens */
    bool    fail_over_on_backend_error;        /* If true, trigger fail over when writing to the backend
                                             * communication socket fails. This is the same behavior of
                                             * pgpool-II 2.2.x or earlier. If set to false, pgpool will report
                                             * an error and disconnect the session.
                                             */

char *recovery_user;                    /* PostgreSQL user name for online recovery */
    char *recovery_password;                /* PostgreSQL user password for online recovery */
    char *recovery_1st_stage_command;        /* Online recovery command in 1st stage */
    char *recovery_2nd_stage_command;        /* Online recovery command in 2nd stage */
    int recovery_timeout;                    /* maximum time in seconds to wait for remote start-up */
    int search_primary_node_timeout;        /* maximum time in seconds to search for new primary
                                             * node after failover
                                             */
    int client_idle_limit_in_recovery;        /* If > 0, the client is forced to be
                                             *  disconnected after n seconds idle
                                             *  This parameter is only valid while in recovery 2nd stage
                                             */
    bool insert_lock;                        /* automatically locking of table with INSERT to keep SERIAL data consistency?
                                             */
                                            
    bool ignore_leading_white_space;        /* ignore leading white spaces of each query */
     bool log_statement;                        /* logs all SQL statements */
     bool log_per_node_statement;            /* logs per node detailed SQL statements */
    char *lobj_lock_table;                    /* table name to lock for rewriting lo_creat */

int debug_level;                        /* debug message verbosity level.
                                             * 0: no message, 1 <= : more verbose
                                              */
    BackendDesc *backend_desc;                /* PostgreSQL Server description. Placed on shared memory */

LOAD_BALANCE_STATUS    load_balance_status[MAX_NUM_BACKENDS];    /* to remember which DB node is selected for load balancing */

/* followings till syslog, does not exist in the configuration file */
    int num_reset_queries;                    /* number of queries in reset_query_list */
    int num_white_function_list;            /* number of functions in white_function_list */
    int num_black_function_list;            /* number of functions in black_function_list */
    int num_white_memqcache_table_list;        /* number of functions in white_memqcache_table_list */
    int num_black_memqcache_table_list;        /* number of functions in black_memqcache_table_list */
    int num_wd_monitoring_interfaces_list;  /* number of items in wd_monitoring_interfaces_list */
    int logsyslog;                            /* flag used to start logging to syslog */

/* ssl configuration */
    bool ssl;                                /* if non 0, activate ssl support (frontend+backend) */
    char *ssl_cert;                            /* path to ssl certificate (frontend only) */
    char *ssl_key;                            /* path to ssl key (frontend only) */
    char *ssl_ca_cert;                        /* path to root (CA) certificate */
    char *ssl_ca_cert_dir;                    /* path to directory containing CA certificates */

int64 relcache_expire;                    /* relation cache life time in seconds */
    int relcache_size;                        /* number of relation cache life entry */
    bool check_temp_table;                    /* enable temporary table check */
    bool check_unlogged_table;                /* enable unlogged table check */
    /* followings are for regex support and do not exist in the configuration file */
    RegPattern *lists_patterns;                /* Precompiled regex patterns for black/white lists */
    int pattc;                                /* number of regexp pattern */
    int current_pattern_size;                /* size of the regex pattern array */

bool memory_cache_enabled;                /* if true, use the memory cache functionality, false by default */
    MemCacheMethod memqcache_method;        /* Cache store method. Either 'shmem'(shared memory) or 'memcached'. 'shmem' by default */
    char *memqcache_memcached_host;            /* Memcached host name. Mandatory if memqcache_method=memcached. */
    int memqcache_memcached_port;            /* Memcached port number. Mandatory if memqcache_method=memcached. */
    int64 memqcache_total_size;                /* Total memory size in bytes for storing memory cache. Mandatory if memqcache_method=shmem. */
    int memqcache_max_num_cache;            /* Total number of cache entries. Mandatory if memqcache_method=shmem. */
    int memqcache_expire;                    /* Memory cache entry life time specified in seconds. 60 by default. */
    bool memqcache_auto_cache_invalidation; /* If true, invalidation of query cache is triggered by corresponding */
                                            /* DDL/DML/DCL(and memqcache_expire).  If false, it is only triggered */
                                            /* by memqcache_expire.  True by default. */
    int memqcache_maxcache;                    /* Maximum SELECT result size in bytes. */
    int memqcache_cache_block_size;            /* Cache block size in bytes. 8192 by default */
    char *memqcache_oiddir;                    /* Temporary work directory to record table oids */
    char **white_memqcache_table_list;        /* list of tables to memqcache */
    char **black_memqcache_table_list;        /* list of tables not to memqcache */

RegPattern *lists_memqcache_table_patterns; /* Precompiled regex patterns for black/white lists */
    int memqcache_table_pattc;                    /* number of regexp pattern */
    int current_memqcache_table_pattern_size;    /* size of the regex pattern array */

/*
     * database_redirect_preference_list = 'postgres:primary,mydb[0-4]:1,mydb[5-9]:2'
     */
    char *database_redirect_preference_list;    /* raw string in pgpool.conf */
    RegArray *redirect_dbnames;                    /* Precompiled regex patterns for db prefrence list */
    Left_right_tokens *db_redirect_tokens;        /* db redirect for dbname and node string */

/*
     * app_name_redirect_preference_list = 'psql:primary,myapp[0-4]:1,myapp[5-9]:standby'
     */
    
     char *app_name_redirect_preference_list;    /* raw string in pgpool.conf */
    RegArray *redirect_app_names;                /* Precompiled regex patterns for app name prefrence list */
    Left_right_tokens *app_name_redirect_tokens;/* app name redirect for app_name and node string */

bool allow_sql_comments;        /* if on, ignore SQL comments when judging if load balance or query cache
                                     * is possible. If off, SQL comments effectively prevent the judgment
                                     * (pre 3.4 behavior). For backward compatibilty sake, default is off.
                                     */
    /*
     * add for watchdog
     */
    
    bool use_watchdog;                        /* Enables watchdog */
    WdLifeCheckMethod wd_lifecheck_method;    /* method of lifecheck. 'heartbeat' or 'query' */
    bool clear_memqcache_on_escalation;        /* Clear query cache on shmem when escalating ?*/
    char *wd_escalation_command;            /* Executes this command at escalation on new active pgpool.*/
    char *wd_de_escalation_command;            /* Executes this command when master pgpool goes down.*/
    char *wd_hostname;                        /* watchdog hostname */
    int wd_port;                            /* watchdog port */
    int wd_priority;                        /* watchdog node priority, during leader election*/
    WdRemoteNodesConfig wd_remote_nodes;    /* watchdog lists */
    char * trusted_servers;                    /* icmp reachable server list (A,B,C) */
    char * delegate_IP;                        /* delegate IP address */
    int  wd_interval;                        /* lifecheck interval (sec) */
    char *wd_authkey;                        /* Authentication key for watchdog communication */
    char * ping_path;                        /* path to ping command */
    char * if_cmd_path;                        /* path to interface up/down command */
    char * if_up_cmd;                        /* ifup command */
    char * if_down_cmd;                        /* ifdown command */
    char * arping_path;                        /* path to arping command */
    char * arping_cmd;                        /* arping command */
    int  wd_life_point;                        /* life point (retry times at lifecheck) */
    char *wd_lifecheck_query;                /* lifecheck query */
    char *wd_lifecheck_dbname;                /* Database name connected for lifecheck */
    char *wd_lifecheck_user;                /* PostgreSQL user name for watchdog */
    char *wd_lifecheck_password;            /* password for watchdog user */
    int wd_heartbeat_port;                    /* Port number for heartbeat lifecheck */
    int wd_heartbeat_keepalive;                /* Interval time of sending heartbeat signal (sec) */
    int wd_heartbeat_deadtime;                /* Deadtime interval for heartbeat signal (sec) */
    WdHbIf hb_if[WD_MAX_IF_NUM];            /* interface devices */
    int num_hb_if;                            /* number of interface devices */
    char **wd_monitoring_interfaces_list;    /* network interface name list to be monitored by watchdog */
} POOL_CONFIG;
    BackendDesc *backend_desc;    
    
typedef struct {
    sig_atomic_t num_backends;        /* Number of used PostgreSQL backends.
                                     * This needs to be a sig_atomic_t type
                                     * since it is replaced by a local
                                     * variable while reloading pgpool.conf.
                                     */

BackendInfo backend_info[MAX_NUM_BACKENDS];
} BackendDesc;
/*
 * PostgreSQL backend descriptor. Placed on shared memory area.
 */
typedef struct {
    char backend_hostname[MAX_DB_HOST_NAMELEN];    /* backend host name */
    int backend_port;    /* backend port numbers */
    BACKEND_STATUS backend_status;    /* backend status */
    double backend_weight;    /* normalized backend load balance ratio */
    double unnormalized_weight; /* descripted parameter */
    char backend_data_directory[MAX_PATH_LENGTH];
    unsigned short flag;        /* various flags */
    unsigned long long int standby_delay;        /* The replication delay against the primary */
} BackendInfo;
                                                
/*
 * get node information specified by node_number
 */
BackendInfo *
pool_get_node_info(int node_number)
{
    if (node_number < 0 || node_number >= NUM_BACKENDS)
        return NULL;

return &BACKEND_INFO(node_number);
}

#define BACKEND_INFO(backend_id) (pool_config->backend_desc->backend_info[(backend_id)])

POOL_CONFIG *pool_config = &_pool_config;

/*
 * do_health_check() performs the health check on all backend nodes.
 * The inout parameter health_check_node_id is the starting backend
 * node number for health check and when the function returns or
 * exits with an error health_check_node_id contains the value
 * of last backend node number on which health check was performed.
 *
 * Function returns false if all backend nodes are down and true if all
 * backend nodes are in healthy state
 */
static bool
do_health_check(bool use_template_db, volatile int *health_check_node_id)
{
    POOL_CONNECTION_POOL_SLOT *slot;
    BackendInfo *bkinfo;
    static char *dbname;
    int i;
    bool all_nodes_healthy = false;

/* Do not execute health check during recovery */
    if (*InRecovery)
        return false;

if (!strcmp(pool_config->health_check_database, ""))
        dbname = use_template_db ? "template1" : "postgres";
    else
        dbname = pool_config->health_check_database;

ereport(DEBUG1,
            (errmsg("doing health check against database:%s user:%s",
                    dbname, pool_config->health_check_user)));

/*
     * Start checking the backed nodes starting from the
     * previously failed node
     */
    for (i=*health_check_node_id;i<pool_config->backend_desc->num_backends;i++)
    {
        *health_check_node_id = i;
        /*
         * Make sure that health check timer has not been expired.
         * Before called health_check(), health_check_timer_expired is
         * set to 0.  However it is possible that while processing DB
         * nodes health check timer expired.
         */
        if (health_check_timer_expired)
        {
            ereport(ERROR,
                (errmsg("health check timer has been already expired before attempting to connect backend node %d", i)));
        }

bkinfo = pool_get_node_info(i);

ereport(DEBUG1,
            (errmsg("Backend DB node %d status is %d", i, bkinfo->backend_status)));

if (bkinfo->backend_status == CON_UNUSED ||
            bkinfo->backend_status == CON_DOWN)
            continue;

all_nodes_healthy = true;
        ereport(DEBUG1,
            (errmsg("Trying to make persistent DB connection to backend node %d having status %d", i, bkinfo->backend_status)));

slot = make_persistent_db_connection(bkinfo->backend_hostname,
                                             bkinfo->backend_port,
                                             dbname,
                                             pool_config->health_check_user,
                                             pool_config->health_check_password, false);

ereport(DEBUG1,
            (errmsg("persistent DB connection to backend node %d having status %d is successful", i, bkinfo->backend_status)));

discard_persistent_db_connection(slot);
    }
    return all_nodes_healthy;
}