~ubuntu-branches/ubuntu/oneiric/pgpool2/oneiric

 * $Header: /cvsroot/pgpool/pgpool-II/pool.h,v 1.56 2010/02/03 08:11:42 t-ishii Exp $

#define DEFAULT_LOGDIR "/tmp"

#define DEFAULT_SOCKET_DIR "/tmp"

 

typedef enum {

        INIT_CONFIG = 1,   /* 0x01 */

        RELOAD_CONFIG = 2  /* 0x02 */

} POOL_CONFIG_CONTEXT;

 

 

/*

 * configuration paramters

 */

typedef struct {

        char *listen_addresses; /* hostnames/IP addresses to listen on */

    int port;   /* port # to bind */

        int pcp_port;                           /* PCP port # to bind */

        char *socket_dir;               /* pgpool socket directory */

        char *pcp_socket_dir;           /* PCP socket directory */

        int pcp_timeout;                        /* PCP timeout for an idle client */

    int num_init_children;      /* # of children initially pre-forked */

    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 *pid_file_name;                /* pid file name */

    char *backend_socket_dir;   /* Unix domain socket directory for the PostgreSQL server */

        int replication_mode;           /* replication mode */

 

        int log_connections;            /* 0:false, 1:true - logs incoming connections */

        int log_hostname;               /* 0:false, 1:true - resolve hostname */

        int enable_pool_hba;            /* 0:false, 1:true - enables pool_hba.conf file authentication */

 

        int load_balance_mode;          /* load balance mode */

 

        int replication_stop_on_mismatch;               /* if there's a data mismatch between master and secondary

                                                                                         * start degenration to stop replication mode

                                                                                         */

        int replicate_select; /* if non 0, replicate SELECT statement when load balancing is disabled. */

        char **reset_query_list;                /* comma separated list of quries to be issued at the end of session */

 

        int print_timestamp;            /* if non 0, print time stamp to each log line */

        int master_slave_mode;          /* if non 0, operate in master/slave mode */

        int connection_cache;           /* if non 0, 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 *failover_command;     /* execute command when failover happens */

        char *failback_command;     /* execute command when failback happens */

 

        /*

         * 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.

         */

        int     fail_over_on_backend_error;

 

        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 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 statge */

        int insert_lock;        /* if non 0, automatically lock table with INSERT to keep SERIAL

                                                   data consistency */

        int ignore_leading_white_space;         /* ignore leading white spaces of each query */

        int log_statement; /* 0:false, 1: true - logs all SQL statements */

        int log_per_node_statement; /* 0:false, 1: true - logs per node detailed SQL statements */

 

        int parallel_mode;      /* if non 0, run in parallel query mode */

 

        int enable_query_cache;         /* if non 0, use query cache. 0 by default */

 

        char *pgpool2_hostname;         /* pgpool2 hostname */

        char *system_db_hostname;       /* system DB hostname */

        int system_db_port;                     /* system DB port number */

        char *system_db_dbname;         /* system DB name */

        char *system_db_schema;         /* system DB schema name */

        char *system_db_user;           /* user name to access system DB */

        char *system_db_password;       /* password to access system DB */

 

        char *lobj_lock_table;          /* table name to lock for rewriting lo_creat */

 

        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 do not exist in the configuration file */

    int current_slot;   /* current backend slot # */

        int replication_enabled;                /* replication mode enabled */

        int master_slave_enabled;               /* master/slave mode enabled */

        int num_reset_queries;          /* number of queries in reset_query_list */

 

        /* ssl configuration */

        int 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 */

} POOL_CONFIG;

 

        char tstate;            /* transaction state (V3 only) */

/*

 * Relation cache structure

 */

#define MAX_ITEM_LENGTH 1024

 

/* Relation lookup cache structure */

 

typedef void *(*func_ptr) ();

 

typedef struct {

        char dbname[MAX_ITEM_LENGTH];   /* database name */

        char relname[MAX_ITEM_LENGTH];  /* table name */

        void *data;     /* user data */

        int refcnt;             /* reference count */

        int session_id;         /* LocalSessionId */

} PoolRelCache;

 

typedef struct {

        int num;                /* number of cache items */

        char sql[MAX_ITEM_LENGTH];      /* Query to relation */

        /*

         * User defined function to be called at data register.

         * Argument is POOL_SELECT_RESULT *.

         * This function must return a pointer to be

         * saved in cache->data.

         */

        func_ptr        register_func;

        /*

         * User defined function to be called at data unregister.

         * Argument cache->data.

         */

        func_ptr        unregister_func;

        bool cache_is_session_local;            /* True if cache life time is session local */

        PoolRelCache *cache;    /* cache data */

} POOL_RELCACHE;

 

 

#ifdef NOT_USED

#define NUM_BACKENDS (in_load_balance? (selected_slot+1) : \

                                          (((!REPLICATION && !PARALLEL_MODE)||master_slave_dml)? Req_info->master_node_id+1: \

                                           pool_config->backend_desc->num_backends))

#endif

/* NUM_BACKENDS now always returns actual number of backends if not in_load_balance */

#define NUM_BACKENDS (in_load_balance ? (selected_slot+1) : pool_config->backend_desc->num_backends)

/* if RAW_MODE, VALID_BACKEND returns the selected node only */

        (RAW_MODE ? (backend_id) == MASTER_NODE_ID : \

        (in_load_balance ? LOAD_BALANCE_STATUS(backend_id) == LOAD_SELECTED : \

    ((BACKEND_INFO(backend_id).backend_status == CON_UP) || \

         (BACKEND_INFO(backend_id).backend_status == CON_CONNECT_WAIT))))

#define MASTER_NODE_ID (in_load_balance? selected_slot : Req_info->master_node_id)

#define IS_MASTER_NODE_ID(node_id) (MASTER_NODE_ID == (node_id))

//#define SECONDARY_CONNECTION(p) ((p)->slots[1])

#define REPLICATION (pool_config->replication_enabled)

#define MASTER_SLAVE (pool_config->master_slave_enabled)

#define MASTER(p) MASTER_CONNECTION(p)->con

//#define SECONDARY(p) SECONDARY_CONNECTION(p)->con

#define TSTATE(p) MASTER(p)->tstate

#define MY_PROCESS_INFO (pids[my_proc_id])

 

extern POOL_CONFIG *pool_config;        /* configuration values */

extern ProcessInfo *pids; /* shmem process information table */

extern int in_load_balance;             /* non 0 if in load balance mode */

extern int selected_slot;               /* selected DB node for load balance */

extern int master_slave_dml;    /* non 0 if master/slave mode is specified in config file */

extern int LocalSessionId;      /* Local session id. incremented when new frontend connected */

 

extern int pool_init_config(void);

extern int pool_get_config(char *confpath, POOL_CONFIG_CONTEXT context);

extern POOL_CONNECTION *pool_open(int fd);

extern void pool_close(POOL_CONNECTION *cp);

extern int pool_read(POOL_CONNECTION *cp, void *buf, int len);

extern char *pool_read2(POOL_CONNECTION *cp, int len);

extern int pool_write(POOL_CONNECTION *cp, void *buf, int len);

extern int pool_flush(POOL_CONNECTION *cp);

extern int pool_flush_it(POOL_CONNECTION *cp);

extern int pool_write_and_flush(POOL_CONNECTION *cp, void *buf, int len);

extern char *pool_read_string(POOL_CONNECTION *cp, int *len, int line);

extern int pool_unread(POOL_CONNECTION *cp, void *data, int len);

 

extern int pool_init_cp(void);

extern POOL_CONNECTION_POOL *pool_create_cp(void);

extern POOL_CONNECTION_POOL *pool_get_cp(char *user, char *database, int protoMajor, int check_socket);

extern void pool_discard_cp(char *user, char *database, int protoMajor);

extern void pool_backend_timer(void);

 

extern void pool_connection_pool_timer(POOL_CONNECTION_POOL *backend);

extern RETSIGTYPE pool_backend_timer_handler(int sig);

 

extern int connect_inet_domain_socket(int secondary_backend);

extern int connect_unix_domain_socket(int secondary_backend);

extern int connect_inet_domain_socket_by_port(char *host, int port);

extern int connect_unix_domain_socket_by_port(int port, char *socket_dir);

extern POOL_STATUS SimpleForwardToBackend(char kind, POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *backend);

extern void pool_set_nonblock(int fd);

extern void pool_unset_nonblock(int fd);

 

/* pool_relcache.c */

extern POOL_RELCACHE *pool_create_relcache(int cachesize, char *sql,

                                                                        func_ptr register_func, func_ptr unregister_func,

                                                                        bool issessionlocal);

extern void pool_discard_relcache(POOL_RELCACHE *relcache);

extern void *pool_search_relcache(POOL_RELCACHE *relcache, POOL_CONNECTION_POOL *backend, char *table);

extern void *int_register_func(POOL_SELECT_RESULT *res);

extern void *int_unregister_func(void *data);

 

/* pool_lobj.c */

extern char *pool_rewrite_lo_creat(char kind, char *packet, int packet_len, POOL_CONNECTION *frontend, POOL_CONNECTION_POOL *backend, int* len);