*** a/doc/src/sgml/config.sgml --- b/doc/src/sgml/config.sgml *************** *** 2152,2161 **** SET ENABLE_SEQSCAN TO OFF; ! ! replication_timeout (integer) ! replication_timeout configuration parameter --- 2152,2161 ---- ! ! wal_sender_timeout (integer) ! wal_sender_timeout configuration parameter *************** *** 2167,2177 **** SET ENABLE_SEQSCAN TO OFF; the postgresql.conf file or on the server command line. The default value is 60 seconds. ! To prevent connections from being terminated prematurely, ! ! must be enabled on the standby, and its value must be less than the ! value of replication_timeout. --- 2167,2189 ---- the postgresql.conf file or on the server command line. The default value is 60 seconds. + + + + + wal_receiver_timeout (integer) + + wal_receiver_timeout configuration parameter + + ! Terminate replication connections that are inactive longer ! than the specified number of milliseconds. This is useful for ! the receiving standby server to detect a primary node crash or network outage. ! A value of zero disables the timeout mechanism. This parameter ! can only be set in ! the postgresql.conf file or on the server command line. ! The default value is 60 seconds. *************** *** 2390,2400 **** SET ENABLE_SEQSCAN TO OFF; the postgresql.conf file or on the server command line. The default value is 10 seconds. - - When is enabled on a sending server, - wal_receiver_status_interval must be enabled, and its value - must be less than the value of replication_timeout. - --- 2402,2407 ---- *** a/src/backend/replication/walreceiver.c --- b/src/backend/replication/walreceiver.c *************** *** 38,43 **** --- 38,44 ---- #include #include + #include "access/transam.h" #include "access/xlog_internal.h" #include "libpq/pqsignal.h" #include "miscadmin.h" *************** *** 62,67 **** walrcv_connect_type walrcv_connect = NULL; --- 63,70 ---- walrcv_receive_type walrcv_receive = NULL; walrcv_send_type walrcv_send = NULL; walrcv_disconnect_type walrcv_disconnect = NULL; + int wal_receiver_timeout = 60 * 1000; /* maximum time to receive one + * WAL data message */ #define NAPTIME_PER_CYCLE 100 /* max sleep time between cycles (100ms) */ *************** *** 121,127 **** static void WalRcvDie(int code, Datum arg); static void XLogWalRcvProcessMsg(unsigned char type, char *buf, Size len); static void XLogWalRcvWrite(char *buf, Size nbytes, XLogRecPtr recptr); static void XLogWalRcvFlush(bool dying); ! static void XLogWalRcvSendReply(void); static void XLogWalRcvSendHSFeedback(void); static void ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime); --- 124,130 ---- static void XLogWalRcvProcessMsg(unsigned char type, char *buf, Size len); static void XLogWalRcvWrite(char *buf, Size nbytes, XLogRecPtr recptr); static void XLogWalRcvFlush(bool dying); ! static void XLogWalRcvSendReply(bool sendImmediate); static void XLogWalRcvSendHSFeedback(void); static void ProcessWalSndrMessage(XLogRecPtr walEnd, TimestampTz sendTime); *************** *** 174,179 **** WalReceiverMain(void) --- 177,185 ---- /* use volatile pointer to prevent code rearrangement */ volatile WalRcvData *walrcv = WalRcv; + TimestampTz last_recv_timestamp; + TimestampTz timeout = 0; + /* * WalRcv should be set up already (if we are a backend, we inherit this * by fork() or EXEC_BACKEND mechanism from the postmaster). *************** *** 282,287 **** WalReceiverMain(void) --- 288,296 ---- MemSet(&reply_message, 0, sizeof(reply_message)); MemSet(&feedback_message, 0, sizeof(feedback_message)); + /* Initialize the last recv timestamp */ + last_recv_timestamp = GetCurrentTimestamp(); + /* Loop until end-of-streaming or error */ for (;;) { *************** *** 316,330 **** WalReceiverMain(void) /* Wait a while for data to arrive */ if (walrcv_receive(NAPTIME_PER_CYCLE, &type, &buf, &len)) { /* Accept the received data, and process it */ XLogWalRcvProcessMsg(type, buf, len); /* Receive any more data we can without sleeping */ while (walrcv_receive(0, &type, &buf, &len)) XLogWalRcvProcessMsg(type, buf, len); /* Let the master know that we received some data. */ ! XLogWalRcvSendReply(); /* * If we've written some records, flush them to disk and let the --- 325,347 ---- /* Wait a while for data to arrive */ if (walrcv_receive(NAPTIME_PER_CYCLE, &type, &buf, &len)) { + /* Something is received from master, so reset last receive time*/ + last_recv_timestamp = GetCurrentTimestamp(); + /* Accept the received data, and process it */ XLogWalRcvProcessMsg(type, buf, len); /* Receive any more data we can without sleeping */ while (walrcv_receive(0, &type, &buf, &len)) + { + /* Something is received from master, so reset last receive time*/ + last_recv_timestamp = GetCurrentTimestamp(); + XLogWalRcvProcessMsg(type, buf, len); + } /* Let the master know that we received some data. */ ! XLogWalRcvSendReply(false); /* * If we've written some records, flush them to disk and let the *************** *** 334,345 **** WalReceiverMain(void) } else { ! /* ! * We didn't receive anything new, but send a status update to the ! * master anyway, to report any progress in applying WAL. ! */ ! XLogWalRcvSendReply(); ! XLogWalRcvSendHSFeedback(); } } } --- 351,380 ---- } else { ! /* Check if time since last receive from standby has reached the configured limit ! * No need to check if it is disabled by giving value as 0*/ ! if (wal_receiver_timeout > 0) ! { ! timeout = TimestampTzPlusMilliseconds(last_recv_timestamp, ! wal_receiver_timeout); ! ! if (GetCurrentTimestamp() >= timeout) ! { ! ereport(ERROR, ! (errmsg("Could not receive any message from WalSender for configured timeout period"))); ! } ! ! /* ! * We didn't receive anything new, for half of receiver replication timeout. ! */ ! timeout = TimestampTzPlusMilliseconds(last_recv_timestamp, ! (wal_receiver_timeout/2)); ! ! if (GetCurrentTimestamp() >= timeout) ! { ! XLogWalRcvSendHSFeedback(); ! } ! } } } } *************** *** 460,465 **** XLogWalRcvProcessMsg(unsigned char type, char *buf, Size len) --- 495,506 ---- memcpy(&keepalive, buf, sizeof(PrimaryKeepaliveMessage)); ProcessWalSndrMessage(keepalive.walEnd, keepalive.sendTime); + + /* For heart-beat message from primary, send an immediate reply*/ + if (keepalive.msgType != 'r') + { + XLogWalRcvSendReply(true); + } break; } default: *************** *** 610,636 **** XLogWalRcvFlush(bool dying) /* Also let the master know that we made some progress */ if (!dying) { ! XLogWalRcvSendReply(); ! XLogWalRcvSendHSFeedback(); } } } /* ! * Send reply message to primary, indicating our current XLOG positions and ! * the current time. */ static void ! XLogWalRcvSendReply(void) { char buf[sizeof(StandbyReplyMessage) + 1]; TimestampTz now; /* * If the user doesn't want status to be reported to the master, be sure * to exit before doing anything at all. */ ! if (wal_receiver_status_interval <= 0) return; /* Get current timestamp. */ --- 651,684 ---- /* Also let the master know that we made some progress */ if (!dying) { ! XLogWalRcvSendReply(false); } } } /* ! * Send reply message to primary, indicating our current XLOG positions, oldest ! * xmin and the current time. ! * The parameter sendImmediate is used to decide whether the reply has to be ! * send immediately or after wal_receiver_status_interval. ! * If the reply is getting sent because of heart-beat from primary, then this param ! * should be true otherwise false. */ static void ! XLogWalRcvSendReply(bool sendImmediate) { char buf[sizeof(StandbyReplyMessage) + 1]; TimestampTz now; + TransactionId nextXid; + uint32 nextEpoch; + TransactionId xmin; + /* * If the user doesn't want status to be reported to the master, be sure * to exit before doing anything at all. */ ! if (!sendImmediate && wal_receiver_status_interval <= 0) return; /* Get current timestamp. */ *************** *** 645,651 **** XLogWalRcvSendReply(void) * this is only for reporting purposes and only on idle systems, that's * probably OK. */ ! if (XLByteEQ(reply_message.write, LogstreamResult.Write) && XLByteEQ(reply_message.flush, LogstreamResult.Flush) && !TimestampDifferenceExceeds(reply_message.sendTime, now, wal_receiver_status_interval * 1000)) --- 693,700 ---- * this is only for reporting purposes and only on idle systems, that's * probably OK. */ ! if (!sendImmediate ! && XLByteEQ(reply_message.write, LogstreamResult.Write) && XLByteEQ(reply_message.flush, LogstreamResult.Flush) && !TimestampDifferenceExceeds(reply_message.sendTime, now, wal_receiver_status_interval * 1000)) *************** *** 654,660 **** XLogWalRcvSendReply(void) /* Construct a new message */ reply_message.write = LogstreamResult.Write; reply_message.flush = LogstreamResult.Flush; ! reply_message.apply = GetXLogReplayRecPtr(NULL); reply_message.sendTime = now; elog(DEBUG2, "sending write %X/%X flush %X/%X apply %X/%X", --- 703,709 ---- /* Construct a new message */ reply_message.write = LogstreamResult.Write; reply_message.flush = LogstreamResult.Flush; ! reply_message.apply = GetXLogReplayRecPtr(NULL); reply_message.sendTime = now; elog(DEBUG2, "sending write %X/%X flush %X/%X apply %X/%X", *************** *** 662,667 **** XLogWalRcvSendReply(void) --- 711,749 ---- (uint32) (reply_message.flush >> 32), (uint32) reply_message.flush, (uint32) (reply_message.apply >> 32), (uint32) reply_message.apply); + if (hot_standby_feedback && HotStandbyActive()) + { + /* + * Make the expensive call to get the oldest xmin once we are certain + * everything else has been checked. + */ + xmin = GetOldestXmin(true, false); + + /* + * Get epoch and adjust if nextXid and oldestXmin are different sides of + * the epoch boundary. + */ + GetNextXidAndEpoch(&nextXid, &nextEpoch); + if (nextXid < xmin) + nextEpoch--; + + /* + * Always send feedback message. + */ + reply_message.xmin = xmin; + reply_message.epoch = nextEpoch; + + elog(DEBUG2, "sending hot standby feedback xmin %u epoch %u", + reply_message.xmin, + reply_message.epoch); + } + else + { + /* Mark xmin invalid so that while primary node process this message it + * can find out that xmin and epoch are not sent as part of reply*/ + reply_message.xmin = InvalidTransactionId; + } + /* Prepend with the message type and send it. */ buf[0] = 'r'; memcpy(&buf[1], &reply_message, sizeof(StandbyReplyMessage)); *************** *** 681,734 **** XLogWalRcvSendHSFeedback(void) uint32 nextEpoch; TransactionId xmin; - /* - * If the user doesn't want status to be reported to the master, be sure - * to exit before doing anything at all. - */ - if (wal_receiver_status_interval <= 0 || !hot_standby_feedback) - return; - /* Get current timestamp. */ now = GetCurrentTimestamp(); /* - * Send feedback at most once per wal_receiver_status_interval. - */ - if (!TimestampDifferenceExceeds(feedback_message.sendTime, now, - wal_receiver_status_interval * 1000)) - return; - - /* - * If Hot Standby is not yet active there is nothing to send. Check this - * after the interval has expired to reduce number of calls. - */ - if (!HotStandbyActive()) - return; - - /* - * Make the expensive call to get the oldest xmin once we are certain - * everything else has been checked. - */ - xmin = GetOldestXmin(true, false); - - /* - * Get epoch and adjust if nextXid and oldestXmin are different sides of - * the epoch boundary. - */ - GetNextXidAndEpoch(&nextXid, &nextEpoch); - if (nextXid < xmin) - nextEpoch--; - - /* * Always send feedback message. */ feedback_message.sendTime = now; - feedback_message.xmin = xmin; - feedback_message.epoch = nextEpoch; - - elog(DEBUG2, "sending hot standby feedback xmin %u epoch %u", - feedback_message.xmin, - feedback_message.epoch); /* Prepend with the message type and send it. */ buf[0] = 'h'; --- 763,775 ---- *** a/src/backend/replication/walsender.c --- b/src/backend/replication/walsender.c *************** *** 80,86 **** bool am_cascading_walsender = false; /* Am I cascading WAL to /* User-settable parameters for walsender */ int max_wal_senders = 0; /* the maximum number of concurrent walsenders */ ! int replication_timeout = 60 * 1000; /* maximum time to send one * WAL data message */ /* * State for WalSndWakeupRequest --- 80,86 ---- /* User-settable parameters for walsender */ int max_wal_senders = 0; /* the maximum number of concurrent walsenders */ ! int wal_sender_timeout = 60 * 1000; /* maximum time to send one * WAL data message */ /* * State for WalSndWakeupRequest *************** *** 132,142 **** static void WalSndKill(int code, Datum arg); static void XLogSend(char *msgbuf, bool *caughtup); static void IdentifySystem(void); static void StartReplication(StartReplicationCmd *cmd); ! static void ProcessStandbyMessage(void); static void ProcessStandbyReplyMessage(void); ! static void ProcessStandbyHSFeedbackMessage(void); ! static void ProcessRepliesIfAny(void); ! static void WalSndKeepalive(char *msgbuf); /* Main entry point for walsender process */ --- 132,142 ---- static void XLogSend(char *msgbuf, bool *caughtup); static void IdentifySystem(void); static void StartReplication(StartReplicationCmd *cmd); ! static void ProcessStandbyMessage(char *output_message); static void ProcessStandbyReplyMessage(void); ! static void ProcessStandbyTransInfo(StandbyReplyMessage reply); ! static void ProcessRepliesIfAny(char *output_message); ! static void WalSndKeepalive(char *msgbuf, bool isReply); /* Main entry point for walsender process */ *************** *** 507,513 **** HandleReplicationCommand(const char *cmd_string) * Check if the remote end has closed the connection. */ static void ! ProcessRepliesIfAny(void) { unsigned char firstchar; int r; --- 507,513 ---- * Check if the remote end has closed the connection. */ static void ! ProcessRepliesIfAny(char *output_message) { unsigned char firstchar; int r; *************** *** 537,543 **** ProcessRepliesIfAny(void) * 'd' means a standby reply wrapped in a CopyData packet. */ case 'd': ! ProcessStandbyMessage(); received = true; break; --- 537,543 ---- * 'd' means a standby reply wrapped in a CopyData packet. */ case 'd': ! ProcessStandbyMessage(output_message); received = true; break; *************** *** 566,572 **** ProcessRepliesIfAny(void) * Process a status update message received from standby. */ static void ! ProcessStandbyMessage(void) { char msgtype; --- 566,572 ---- * Process a status update message received from standby. */ static void ! ProcessStandbyMessage(char *output_message) { char msgtype; *************** *** 595,601 **** ProcessStandbyMessage(void) break; case 'h': ! ProcessStandbyHSFeedbackMessage(); break; default: --- 595,605 ---- break; case 'h': ! /* ! * Once this message is received, we should send an immediate reply ! * to standby node in order to indicate connection is alive ! */ ! WalSndKeepalive(output_message, true); break; default: *************** *** 607,613 **** ProcessStandbyMessage(void) } /* ! * Regular reply from standby advising of WAL positions on standby server. */ static void ProcessStandbyReplyMessage(void) --- 611,617 ---- } /* ! * Regular reply from standby advising of WAL positions and transaction on standby server. */ static void ProcessStandbyReplyMessage(void) *************** *** 636,659 **** ProcessStandbyReplyMessage(void) SpinLockRelease(&walsnd->mutex); } if (!am_cascading_walsender) SyncRepReleaseWaiters(); } /* ! * Hot Standby feedback */ static void ! ProcessStandbyHSFeedbackMessage(void) { - StandbyHSFeedbackMessage reply; TransactionId nextXid; uint32 nextEpoch; - /* Decipher the reply message */ - pq_copymsgbytes(&reply_message, (char *) &reply, - sizeof(StandbyHSFeedbackMessage)); - elog(DEBUG2, "hot standby feedback xmin %u epoch %u", reply.xmin, reply.epoch); --- 640,660 ---- SpinLockRelease(&walsnd->mutex); } + ProcessStandbyTransInfo(reply); + if (!am_cascading_walsender) SyncRepReleaseWaiters(); } /* ! * Stores the transaction info received from standby */ static void ! ProcessStandbyTransInfo(StandbyReplyMessage reply) { TransactionId nextXid; uint32 nextEpoch; elog(DEBUG2, "hot standby feedback xmin %u epoch %u", reply.xmin, reply.epoch); *************** *** 765,771 **** WalSndLoop(void) } /* Check for input from the client */ ! ProcessRepliesIfAny(); /* * If we don't have any pending data in the output buffer, try to send --- 766,772 ---- } /* Check for input from the client */ ! ProcessRepliesIfAny(output_message); /* * If we don't have any pending data in the output buffer, try to send *************** *** 835,856 **** WalSndLoop(void) wakeEvents = WL_LATCH_SET | WL_POSTMASTER_DEATH | WL_SOCKET_READABLE | WL_TIMEOUT; if (pq_is_send_pending()) wakeEvents |= WL_SOCKET_WRITEABLE; ! else if (MyWalSnd->sendKeepalive) { ! WalSndKeepalive(output_message); /* Try to flush pending output to the client */ if (pq_flush_if_writable() != 0) break; } /* Determine time until replication timeout */ ! if (replication_timeout > 0) { timeout = TimestampTzPlusMilliseconds(last_reply_timestamp, ! replication_timeout); ! sleeptime = 1 + (replication_timeout / 10); } /* Sleep until something happens or replication timeout */ --- 836,867 ---- wakeEvents = WL_LATCH_SET | WL_POSTMASTER_DEATH | WL_SOCKET_READABLE | WL_TIMEOUT; + /* + * Check if half of wal_sender_timeout has lapsed without receiving any reply from standby + * then send a keep-alive message to standby to detect standby status + */ + timeout = TimestampTzPlusMilliseconds(last_reply_timestamp, + (wal_sender_timeout/2)); + /* + * send keepalive message if sendkeepalive is enabled or WAL send status + * interval is greater than zero. + */ if (pq_is_send_pending()) wakeEvents |= WL_SOCKET_WRITEABLE; ! else if (MyWalSnd->sendKeepalive || (wal_sender_timeout > 0 && GetCurrentTimestamp() >= timeout)) { ! WalSndKeepalive(output_message, false); /* Try to flush pending output to the client */ if (pq_flush_if_writable() != 0) break; } /* Determine time until replication timeout */ ! if (wal_sender_timeout > 0) { timeout = TimestampTzPlusMilliseconds(last_reply_timestamp, ! wal_sender_timeout); ! sleeptime = 1 + (wal_sender_timeout / 10); } /* Sleep until something happens or replication timeout */ *************** *** 862,868 **** WalSndLoop(void) * possibility that the client replied just as we reached the * timeout ... he's supposed to reply *before* that. */ ! if (replication_timeout > 0 && GetCurrentTimestamp() >= timeout) { /* --- 873,879 ---- * possibility that the client replied just as we reached the * timeout ... he's supposed to reply *before* that. */ ! if (wal_sender_timeout > 0 && GetCurrentTimestamp() >= timeout) { /* *************** *** 1617,1630 **** pg_stat_get_wal_senders(PG_FUNCTION_ARGS) return (Datum) 0; } static void ! WalSndKeepalive(char *msgbuf) { PrimaryKeepaliveMessage keepalive_message; /* Construct a new message */ keepalive_message.walEnd = sentPtr; keepalive_message.sendTime = GetCurrentTimestamp(); elog(DEBUG2, "sending replication keepalive"); --- 1628,1655 ---- return (Datum) 0; } + /* + * This function is used to send keepalive message to standby. + * Depending on the parameter isReply value as true or false, + * it sends reply or heart-beat message to standby respectively + */ + static void ! WalSndKeepalive(char *msgbuf, bool isReply) { PrimaryKeepaliveMessage keepalive_message; /* Construct a new message */ keepalive_message.walEnd = sentPtr; keepalive_message.sendTime = GetCurrentTimestamp(); + if (isReply) + { + keepalive_message.msgType = 'r'; + } + else + { + keepalive_message.msgType = 'h'; + } elog(DEBUG2, "sending replication keepalive"); *** a/src/backend/utils/misc/guc.c --- b/src/backend/utils/misc/guc.c *************** *** 1596,1601 **** static struct config_int ConfigureNamesInt[] = --- 1596,1612 ---- }, { + {"wal_receiver_timeout", PGC_SIGHUP, REPLICATION_STANDBY, + gettext_noop("Sets the maximum wait time to receive data from master."), + NULL, + GUC_UNIT_MS + }, + &wal_receiver_timeout, + 60 * 1000, 0, INT_MAX, + NULL, NULL, NULL + }, + + { {"max_connections", PGC_POSTMASTER, CONN_AUTH_SETTINGS, gettext_noop("Sets the maximum number of concurrent connections."), NULL *************** *** 2019,2030 **** static struct config_int ConfigureNamesInt[] = }, { ! {"replication_timeout", PGC_SIGHUP, REPLICATION_SENDING, gettext_noop("Sets the maximum time to wait for WAL replication."), NULL, GUC_UNIT_MS }, ! &replication_timeout, 60 * 1000, 0, INT_MAX, NULL, NULL, NULL }, --- 2030,2041 ---- }, { ! {"wal_sender_timeout", PGC_SIGHUP, REPLICATION_SENDING, gettext_noop("Sets the maximum time to wait for WAL replication."), NULL, GUC_UNIT_MS }, ! &wal_sender_timeout, 60 * 1000, 0, INT_MAX, NULL, NULL, NULL }, *************** *** 2381,2387 **** static struct config_int ConfigureNamesInt[] = 1024, 100, 102400, NULL, NULL, NULL }, ! /* End-of-list marker */ { {NULL, 0, 0, NULL, NULL}, NULL, 0, 0, 0, NULL, NULL, NULL --- 2392,2398 ---- 1024, 100, 102400, NULL, NULL, NULL }, ! /* End-of-list marker */ { {NULL, 0, 0, NULL, NULL}, NULL, 0, 0, 0, NULL, NULL, NULL *** a/src/backend/utils/misc/postgresql.conf.sample --- b/src/backend/utils/misc/postgresql.conf.sample *************** *** 210,216 **** #max_wal_senders = 0 # max number of walsender processes # (change requires restart) #wal_keep_segments = 0 # in logfile segments, 16MB each; 0 disables ! #replication_timeout = 60s # in milliseconds; 0 disables # - Master Server - --- 210,216 ---- #max_wal_senders = 0 # max number of walsender processes # (change requires restart) #wal_keep_segments = 0 # in logfile segments, 16MB each; 0 disables ! #wal_sender_timeout = 60s # in milliseconds; 0 disables # - Master Server - *************** *** 234,242 **** # when reading streaming WAL; # -1 allows indefinite delay #wal_receiver_status_interval = 10s # send replies at least this often ! # 0 disables #hot_standby_feedback = off # send info from standby to prevent # query conflicts #------------------------------------------------------------------------------ --- 234,244 ---- # when reading streaming WAL; # -1 allows indefinite delay #wal_receiver_status_interval = 10s # send replies at least this often ! # in seconds; 0 disables #hot_standby_feedback = off # send info from standby to prevent # query conflicts + #wal_receiver_timeout = 60s # in milliseconds; 0 disables; time + # till receiver waits for communication from master. #------------------------------------------------------------------------------ *** a/src/include/replication/walprotocol.h --- b/src/include/replication/walprotocol.h *************** *** 27,32 **** typedef struct --- 27,37 ---- /* Sender's system clock at the time of transmission */ TimestampTz sendTime; + + /* This is the message type. If its type is r i.e. reply then it overrides the keepalive + * and it serves the purpose of reply for heart-beat message from standby. + */ + char msgType; } WalSndrMessage; *************** *** 78,83 **** typedef struct --- 83,102 ---- XLogRecPtr flush; XLogRecPtr apply; + /* + * Transaction information (Earlier these field were used to be with HS Feedback + * message but now both of the messages are combined so combining structure + * members also + */ + /* + * 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; } StandbyReplyMessage; *************** *** 90,103 **** typedef struct */ 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; --- 109,114 ---- *** a/src/include/replication/walreceiver.h --- b/src/include/replication/walreceiver.h *************** *** 19,24 **** --- 19,25 ---- extern int wal_receiver_status_interval; extern bool hot_standby_feedback; + extern int wal_receiver_timeout; /* * MAXCONNINFO: maximum size of a connection string. *** a/src/include/replication/walsender.h --- b/src/include/replication/walsender.h *************** *** 25,31 **** extern bool wake_wal_senders; /* user-settable parameters */ extern int max_wal_senders; ! extern int replication_timeout; extern void WalSenderMain(void) __attribute__((noreturn)); extern void WalSndSignals(void); --- 25,31 ---- /* user-settable parameters */ extern int max_wal_senders; ! extern int wal_sender_timeout; extern void WalSenderMain(void) __attribute__((noreturn)); extern void WalSndSignals(void);