init
This commit is contained in:
blue-lemon0104
19
pg_include/replication/basebackup.h
Executable file
19
pg_include/replication/basebackup.h
Executable file
@@ -0,0 +1,19 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* basebackup.h
|
||||
* Exports from replication/basebackup.c.
|
||||
*
|
||||
* Portions Copyright (c) 2010-2012, PostgreSQL Global Development Group
|
||||
*
|
||||
* src/include/replication/basebackup.h
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#ifndef _BASEBACKUP_H
|
||||
#define _BASEBACKUP_H
|
||||
|
||||
#include "nodes/replnodes.h"
|
||||
|
||||
extern void SendBaseBackup(BaseBackupCmd *cmd);
|
||||
|
||||
#endif /* _BASEBACKUP_H */
|
||||
56
pg_include/replication/syncrep.h
Executable file
56
pg_include/replication/syncrep.h
Executable file
@@ -0,0 +1,56 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* syncrep.h
|
||||
* Exports from replication/syncrep.c.
|
||||
*
|
||||
* Portions Copyright (c) 2010-2012, PostgreSQL Global Development Group
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* src/include/replication/syncrep.h
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#ifndef _SYNCREP_H
|
||||
#define _SYNCREP_H
|
||||
|
||||
#include "access/xlogdefs.h"
|
||||
#include "utils/guc.h"
|
||||
|
||||
#define SyncRepRequested() \
|
||||
(max_wal_senders > 0 && synchronous_commit > SYNCHRONOUS_COMMIT_LOCAL_FLUSH)
|
||||
|
||||
/* SyncRepWaitMode */
|
||||
#define SYNC_REP_NO_WAIT -1
|
||||
#define SYNC_REP_WAIT_WRITE 0
|
||||
#define SYNC_REP_WAIT_FLUSH 1
|
||||
|
||||
#define NUM_SYNC_REP_WAIT_MODE 2
|
||||
|
||||
/* syncRepState */
|
||||
#define SYNC_REP_NOT_WAITING 0
|
||||
#define SYNC_REP_WAITING 1
|
||||
#define SYNC_REP_WAIT_COMPLETE 2
|
||||
|
||||
/* user-settable parameters for synchronous replication */
|
||||
extern char *SyncRepStandbyNames;
|
||||
|
||||
/* called by user backend */
|
||||
extern void SyncRepWaitForLSN(XLogRecPtr XactCommitLSN);
|
||||
|
||||
/* called at backend exit */
|
||||
extern void SyncRepCleanupAtProcExit(void);
|
||||
|
||||
/* called by wal sender */
|
||||
extern void SyncRepInitConfig(void);
|
||||
extern void SyncRepReleaseWaiters(void);
|
||||
|
||||
/* called by wal writer */
|
||||
extern void SyncRepUpdateSyncStandbysDefined(void);
|
||||
|
||||
/* called by various procs */
|
||||
extern int SyncRepWakeQueue(bool all, int mode);
|
||||
|
||||
extern bool check_synchronous_standby_names(char **newval, void **extra, GucSource source);
|
||||
extern void assign_synchronous_commit(int newval, void *extra);
|
||||
|
||||
#endif /* _SYNCREP_H */
|
||||
116
pg_include/replication/walprotocol.h
Executable file
116
pg_include/replication/walprotocol.h
Executable file
@@ -0,0 +1,116 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* walprotocol.h
|
||||
* Definitions relevant to the streaming WAL transmission protocol.
|
||||
*
|
||||
* Portions Copyright (c) 2010-2012, PostgreSQL Global Development Group
|
||||
*
|
||||
* src/include/replication/walprotocol.h
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#ifndef _WALPROTOCOL_H
|
||||
#define _WALPROTOCOL_H
|
||||
|
||||
#include "access/xlogdefs.h"
|
||||
#include "datatype/timestamp.h"
|
||||
|
||||
|
||||
/*
|
||||
* All messages from WalSender must contain these fields to allow us to
|
||||
* correctly calculate the replication delay.
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
/* Current end of WAL on the sender */
|
||||
XLogRecPtr walEnd;
|
||||
|
||||
/* Sender's system clock at the time of transmission */
|
||||
TimestampTz sendTime;
|
||||
} WalSndrMessage;
|
||||
|
||||
|
||||
/*
|
||||
* Header for a WAL data message (message type 'w'). This is wrapped within
|
||||
* a CopyData message at the FE/BE protocol level.
|
||||
*
|
||||
* The header is followed by actual WAL data. Note that the data length is
|
||||
* not specified in the header --- it's just whatever remains in the message.
|
||||
*
|
||||
* walEnd and sendTime are not essential data, but are provided in case
|
||||
* the receiver wants to adjust its behavior depending on how far behind
|
||||
* it is.
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
/* WAL start location of the data included in this message */
|
||||
XLogRecPtr dataStart;
|
||||
|
||||
/* Current end of WAL on the sender */
|
||||
XLogRecPtr walEnd;
|
||||
|
||||
/* Sender's system clock at the time of transmission */
|
||||
TimestampTz sendTime;
|
||||
} WalDataMessageHeader;
|
||||
|
||||
/*
|
||||
* Keepalive message from primary (message type 'k'). (lowercase k)
|
||||
* This is wrapped within a CopyData message at the FE/BE protocol level.
|
||||
*
|
||||
* Note that the data length is not specified here.
|
||||
*/
|
||||
typedef WalSndrMessage PrimaryKeepaliveMessage;
|
||||
|
||||
/*
|
||||
* Reply message from standby (message type 'r'). This is wrapped within
|
||||
* a CopyData message at the FE/BE protocol level.
|
||||
*
|
||||
* Note that the data length is not specified here.
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
/*
|
||||
* The xlog locations that have been written, flushed, and applied by
|
||||
* standby-side. These may be invalid if the standby-side is unable to or
|
||||
* chooses not to report these.
|
||||
*/
|
||||
XLogRecPtr write;
|
||||
XLogRecPtr flush;
|
||||
XLogRecPtr apply;
|
||||
|
||||
/* Sender's system clock at the time of transmission */
|
||||
TimestampTz sendTime;
|
||||
} StandbyReplyMessage;
|
||||
|
||||
/*
|
||||
* Hot Standby feedback from standby (message type 'h'). This is wrapped within
|
||||
* a CopyData message at the FE/BE protocol level.
|
||||
*
|
||||
* Note that the data length is not specified here.
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
/*
|
||||
* The current xmin and epoch from the standby, for Hot Standby feedback.
|
||||
* This may be invalid if the standby-side does not support feedback, or
|
||||
* Hot Standby is not yet available.
|
||||
*/
|
||||
TransactionId xmin;
|
||||
uint32 epoch;
|
||||
|
||||
/* Sender's system clock at the time of transmission */
|
||||
TimestampTz sendTime;
|
||||
} StandbyHSFeedbackMessage;
|
||||
|
||||
/*
|
||||
* Maximum data payload in a WAL data message. Must be >= XLOG_BLCKSZ.
|
||||
*
|
||||
* We don't have a good idea of what a good value would be; there's some
|
||||
* overhead per message in both walsender and walreceiver, but on the other
|
||||
* hand sending large batches makes walsender less responsive to signals
|
||||
* because signals are checked only between messages. 128kB (with
|
||||
* default 8k blocks) seems like a reasonable guess for now.
|
||||
*/
|
||||
#define MAX_SEND_SIZE (XLOG_BLCKSZ * 16)
|
||||
|
||||
#endif /* _WALPROTOCOL_H */
|
||||
129
pg_include/replication/walreceiver.h
Executable file
129
pg_include/replication/walreceiver.h
Executable file
@@ -0,0 +1,129 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* walreceiver.h
|
||||
* Exports from replication/walreceiverfuncs.c.
|
||||
*
|
||||
* Portions Copyright (c) 2010-2012, PostgreSQL Global Development Group
|
||||
*
|
||||
* src/include/replication/walreceiver.h
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#ifndef _WALRECEIVER_H
|
||||
#define _WALRECEIVER_H
|
||||
|
||||
#include "access/xlog.h"
|
||||
#include "access/xlogdefs.h"
|
||||
#include "storage/spin.h"
|
||||
#include "pgtime.h"
|
||||
|
||||
extern int wal_receiver_status_interval;
|
||||
extern bool hot_standby_feedback;
|
||||
|
||||
/*
|
||||
* MAXCONNINFO: maximum size of a connection string.
|
||||
*
|
||||
* XXX: Should this move to pg_config_manual.h?
|
||||
*/
|
||||
#define MAXCONNINFO 1024
|
||||
|
||||
/* Can we allow the standby to accept replication connection from another standby? */
|
||||
#define AllowCascadeReplication() (EnableHotStandby && max_wal_senders > 0)
|
||||
|
||||
/*
|
||||
* Values for WalRcv->walRcvState.
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
WALRCV_STOPPED, /* stopped and mustn't start up again */
|
||||
WALRCV_STARTING, /* launched, but the process hasn't
|
||||
* initialized yet */
|
||||
WALRCV_RUNNING, /* walreceiver is running */
|
||||
WALRCV_STOPPING /* requested to stop, but still running */
|
||||
} WalRcvState;
|
||||
|
||||
/* Shared memory area for management of walreceiver process */
|
||||
typedef struct
|
||||
{
|
||||
/*
|
||||
* PID of currently active walreceiver process, its current state and
|
||||
* start time (actually, the time at which it was requested to be
|
||||
* started).
|
||||
*/
|
||||
pid_t pid;
|
||||
WalRcvState walRcvState;
|
||||
pg_time_t startTime;
|
||||
|
||||
/*
|
||||
* receiveStart is the first byte position that will be received. When
|
||||
* startup process starts the walreceiver, it sets receiveStart to the
|
||||
* point where it wants the streaming to begin.
|
||||
*/
|
||||
XLogRecPtr receiveStart;
|
||||
|
||||
/*
|
||||
* receivedUpto-1 is the last byte position that has already been
|
||||
* received. At the first startup of walreceiver, receivedUpto is set to
|
||||
* receiveStart. After that, walreceiver updates this whenever it flushes
|
||||
* the received WAL to disk.
|
||||
*/
|
||||
XLogRecPtr receivedUpto;
|
||||
|
||||
/*
|
||||
* latestChunkStart is the starting byte position of the current "batch"
|
||||
* of received WAL. It's actually the same as the previous value of
|
||||
* receivedUpto before the last flush to disk. Startup process can use
|
||||
* this to detect whether it's keeping up or not.
|
||||
*/
|
||||
XLogRecPtr latestChunkStart;
|
||||
|
||||
/*
|
||||
* Time of send and receive of any message received.
|
||||
*/
|
||||
TimestampTz lastMsgSendTime;
|
||||
TimestampTz lastMsgReceiptTime;
|
||||
|
||||
/*
|
||||
* Latest reported end of WAL on the sender
|
||||
*/
|
||||
XLogRecPtr latestWalEnd;
|
||||
TimestampTz latestWalEndTime;
|
||||
|
||||
/*
|
||||
* connection string; is used for walreceiver to connect with the primary.
|
||||
*/
|
||||
char conninfo[MAXCONNINFO];
|
||||
|
||||
slock_t mutex; /* locks shared variables shown above */
|
||||
} WalRcvData;
|
||||
|
||||
extern WalRcvData *WalRcv;
|
||||
|
||||
/* libpqwalreceiver hooks */
|
||||
typedef bool (*walrcv_connect_type) (char *conninfo, XLogRecPtr startpoint);
|
||||
extern PGDLLIMPORT walrcv_connect_type walrcv_connect;
|
||||
|
||||
typedef bool (*walrcv_receive_type) (int timeout, unsigned char *type,
|
||||
char **buffer, int *len);
|
||||
extern PGDLLIMPORT walrcv_receive_type walrcv_receive;
|
||||
|
||||
typedef void (*walrcv_send_type) (const char *buffer, int nbytes);
|
||||
extern PGDLLIMPORT walrcv_send_type walrcv_send;
|
||||
|
||||
typedef void (*walrcv_disconnect_type) (void);
|
||||
extern PGDLLIMPORT walrcv_disconnect_type walrcv_disconnect;
|
||||
|
||||
/* prototypes for functions in walreceiver.c */
|
||||
extern void WalReceiverMain(void);
|
||||
|
||||
/* prototypes for functions in walreceiverfuncs.c */
|
||||
extern Size WalRcvShmemSize(void);
|
||||
extern void WalRcvShmemInit(void);
|
||||
extern void ShutdownWalRcv(void);
|
||||
extern bool WalRcvInProgress(void);
|
||||
extern void RequestXLogStreaming(XLogRecPtr recptr, const char *conninfo);
|
||||
extern XLogRecPtr GetWalRcvWriteRecPtr(XLogRecPtr *latestChunkStart);
|
||||
extern int GetReplicationApplyDelay(void);
|
||||
extern int GetReplicationTransferLatency(void);
|
||||
|
||||
#endif /* _WALRECEIVER_H */
|
||||
38
pg_include/replication/walsender.h
Executable file
38
pg_include/replication/walsender.h
Executable file
@@ -0,0 +1,38 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* walsender.h
|
||||
* Exports from replication/walsender.c.
|
||||
*
|
||||
* Portions Copyright (c) 2010-2012, PostgreSQL Global Development Group
|
||||
*
|
||||
* src/include/replication/walsender.h
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#ifndef _WALSENDER_H
|
||||
#define _WALSENDER_H
|
||||
|
||||
#include <signal.h>
|
||||
|
||||
#include "fmgr.h"
|
||||
|
||||
/* global state */
|
||||
extern bool am_walsender;
|
||||
extern bool am_cascading_walsender;
|
||||
extern volatile sig_atomic_t walsender_shutdown_requested;
|
||||
extern volatile sig_atomic_t walsender_ready_to_stop;
|
||||
|
||||
/* user-settable parameters */
|
||||
extern int max_wal_senders;
|
||||
extern int replication_timeout;
|
||||
|
||||
extern int WalSenderMain(void);
|
||||
extern void WalSndSignals(void);
|
||||
extern Size WalSndShmemSize(void);
|
||||
extern void WalSndShmemInit(void);
|
||||
extern void WalSndWakeup(void);
|
||||
extern void WalSndRqstFileReload(void);
|
||||
|
||||
extern Datum pg_stat_get_wal_senders(PG_FUNCTION_ARGS);
|
||||
|
||||
#endif /* _WALSENDER_H */
|
||||
113
pg_include/replication/walsender_private.h
Executable file
113
pg_include/replication/walsender_private.h
Executable file
@@ -0,0 +1,113 @@
|
||||
/*-------------------------------------------------------------------------
|
||||
*
|
||||
* walsender_private.h
|
||||
* Private definitions from replication/walsender.c.
|
||||
*
|
||||
* Portions Copyright (c) 2010-2012, PostgreSQL Global Development Group
|
||||
*
|
||||
* src/include/replication/walsender_private.h
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
#ifndef _WALSENDER_PRIVATE_H
|
||||
#define _WALSENDER_PRIVATE_H
|
||||
|
||||
#include "access/xlog.h"
|
||||
#include "nodes/nodes.h"
|
||||
#include "replication/syncrep.h"
|
||||
#include "storage/latch.h"
|
||||
#include "storage/shmem.h"
|
||||
#include "storage/spin.h"
|
||||
|
||||
typedef enum WalSndState
|
||||
{
|
||||
WALSNDSTATE_STARTUP = 0,
|
||||
WALSNDSTATE_BACKUP,
|
||||
WALSNDSTATE_CATCHUP,
|
||||
WALSNDSTATE_STREAMING
|
||||
} WalSndState;
|
||||
|
||||
/*
|
||||
* Each walsender has a WalSnd struct in shared memory.
|
||||
*/
|
||||
typedef struct WalSnd
|
||||
{
|
||||
pid_t pid; /* this walsender's process id, or 0 */
|
||||
WalSndState state; /* this walsender's state */
|
||||
XLogRecPtr sentPtr; /* WAL has been sent up to this point */
|
||||
bool needreload; /* does currently-open file need to be
|
||||
* reloaded? */
|
||||
bool sendKeepalive; /* do we send keepalives on this connection? */
|
||||
|
||||
/*
|
||||
* The xlog locations that have been written, flushed, and applied by
|
||||
* standby-side. These may be invalid if the standby-side has not offered
|
||||
* values yet.
|
||||
*/
|
||||
XLogRecPtr write;
|
||||
XLogRecPtr flush;
|
||||
XLogRecPtr apply;
|
||||
|
||||
/* Protects shared variables shown above. */
|
||||
slock_t mutex;
|
||||
|
||||
/*
|
||||
* Latch used by backends to wake up this walsender when it has work to
|
||||
* do.
|
||||
*/
|
||||
Latch latch;
|
||||
|
||||
/*
|
||||
* The priority order of the standby managed by this WALSender, as listed
|
||||
* in synchronous_standby_names, or 0 if not-listed. Protected by
|
||||
* SyncRepLock.
|
||||
*/
|
||||
int sync_standby_priority;
|
||||
} WalSnd;
|
||||
|
||||
extern WalSnd *MyWalSnd;
|
||||
|
||||
/* There is one WalSndCtl struct for the whole database cluster */
|
||||
typedef struct
|
||||
{
|
||||
/*
|
||||
* Synchronous replication queue with one queue per request type.
|
||||
* Protected by SyncRepLock.
|
||||
*/
|
||||
SHM_QUEUE SyncRepQueue[NUM_SYNC_REP_WAIT_MODE];
|
||||
|
||||
/*
|
||||
* Current location of the head of the queue. All waiters should have a
|
||||
* waitLSN that follows this value. Protected by SyncRepLock.
|
||||
*/
|
||||
XLogRecPtr lsn[NUM_SYNC_REP_WAIT_MODE];
|
||||
|
||||
/*
|
||||
* Are any sync standbys defined? Waiting backends can't reload the
|
||||
* config file safely, so checkpointer updates this value as needed.
|
||||
* Protected by SyncRepLock.
|
||||
*/
|
||||
bool sync_standbys_defined;
|
||||
|
||||
WalSnd walsnds[1]; /* VARIABLE LENGTH ARRAY */
|
||||
} WalSndCtlData;
|
||||
|
||||
extern WalSndCtlData *WalSndCtl;
|
||||
|
||||
|
||||
extern void WalSndSetState(WalSndState state);
|
||||
extern void XLogRead(char *buf, XLogRecPtr startptr, Size count);
|
||||
|
||||
/*
|
||||
* Internal functions for parsing the replication grammar, in repl_gram.y and
|
||||
* repl_scanner.l
|
||||
*/
|
||||
extern int replication_yyparse(void);
|
||||
extern int replication_yylex(void);
|
||||
extern void replication_yyerror(const char *str);
|
||||
extern void replication_scanner_init(const char *query_string);
|
||||
extern void replication_scanner_finish(void);
|
||||
|
||||
extern Node *replication_parse_result;
|
||||
|
||||
#endif /* _WALSENDER_PRIVATE_H */
|
||||
Reference in New Issue
Block a user