<application>pg_receivexlog</application>.

</para>

<para>

Unlike the standby's WAL receiver, <application>pg_receivexlog</>

flushes WAL data only when WAL file is closed, by default.

<literal>--synchronous</> option must be specified to flush WAL data

in real time and ensure it's safely flushed to disk.

</para>

<para>

The transaction log is streamed over a regular

<productname>PostgreSQL</productname> connection, and uses the replication

</listitem>

</varlistentry>

<varlistentry>

<term><option>-F <replaceable class="parameter">interval</replaceable></option></term>

<term><option>--fsync-interval=<replaceable class="parameter">interval</replaceable></option></term>

<listitem>

<para>

Specifies the maximum time to issue sync commands to ensure the

received WAL file is safely flushed to disk, in seconds. The default

value is zero, which disables issuing fsyncs except when WAL file is

closed. If <literal>-1</literal> is specified, WAL file is flushed as

soon as possible, that is, as soon as there are WAL data which has

not been flushed yet.

</para>

</listitem>

</varlistentry>

<varlistentry>

<term><option>-n</option></term>

<term><option>--no-loop</option></term>

When this option is used, <application>pg_receivexlog</> will report

a flush position to the server, indicating when each segment has been

synchronized to disk so that the server can remove that segment if it

is not otherwise needed. When using this parameter, it is important

to make sure that <application>pg_receivexlog</> cannot become the

synchronous standby through an incautious setting of

<xref linkend="guc-synchronous-standby-names">; it does not flush

data frequently enough for this to work correctly.

is not otherwise needed. <literal>--synchronous</literal> option must

be specified when making <application>pg_receivexlog</> run as

synchronous standby by using replication slot. Otherwise WAL data

cannot be flushed frequently enough for this to work correctly.

</para>

</listitem>

</varlistentry>

<varlistentry>

<term><option>--synchronous</option></term>

<listitem>

<para>

Issue sync commands as soon as there is WAL data which has not been

flushed yet. Also status packets are sent back to the server just after

WAL data is flushed whatever <literal>--status-interval</> is set to.

</para>

</listitem>

</varlistentry>

<varlistentry>

<term><option>-v</option></term>

<term><option>--verbose</option></term>

if (!ReceiveXlogStream(param->bgconn,param->startptr,param->timeline,

param->sysidentifier,param->xlogdir,

reached_end_position,standby_message_timeout,

NULL,0))

NULL,false))

staticintverbose=0;

staticintnoloop=0;

staticintstandby_message_timeout=10*1000;/* 10 sec = default */

staticintfsync_interval=0;/* 0 = default */

staticvolatilebooltime_to_abort= false;

staticbooldo_create_slot= false;

staticbooldo_drop_slot= false;

staticboolsynchronous= false;

staticvoidusage(void);

printf(_(" %s [OPTION]...\n"),progname);

printf(_("\nOptions:\n"));

printf(_(" -D, --directory=DIR receive transaction log files into this directory\n"));

printf(_(" -F --fsync-interval=SECS\n"

" time between fsyncs to transaction log files (default: %d)\n"), (fsync_interval /1000));

printf(_(" -n, --no-loop do not loop on connection lost\n"));

printf(_(" -s, --status-interval=SECS\n"

" time between status packets sent to server (default: %d)\n"), (standby_message_timeout /1000));

printf(_(" -S, --slot=SLOTNAME replication slot to use\n"));

printf(_(" --synchronous flush transaction log immediately after writing\n"));

printf(_(" -v, --verbose output verbose messages\n"));

printf(_(" -V, --version output version information, then exit\n"));

printf(_(" -?, --help show this help, then exit\n"));

ReceiveXlogStream(conn,startpos,starttli,NULL,basedir,

stop_streaming,standby_message_timeout,".partial",

fsync_interval);

synchronous);

PQfinish(conn);

conn=NULL;

{"port",required_argument,NULL,'p'},

{"username",required_argument,NULL,'U'},

{"no-loop",no_argument,NULL,'n'},

{"fsync-interval",required_argument,NULL,'F'},

{"no-password",no_argument,NULL,'w'},

{"password",no_argument,NULL,'W'},

{"status-interval",required_argument,NULL,'s'},

{"create-slot",no_argument,NULL,1},

{"drop-slot",no_argument,NULL,2},

{"synchronous",no_argument,NULL,3},

{NULL,0,NULL,0}

};

}

}

while ((c=getopt_long(argc,argv,"D:d:h:p:U:s:S:nF:wWv",

while ((c=getopt_long(argc,argv,"D:d:h:p:U:s:S:nwWv",

long_options,&option_index))!=-1)

{

switch (c)

case'n':

noloop=1;

break;

case'F':

fsync_interval=atoi(optarg)*1000;

if (fsync_interval<-1000)

{

fprintf(stderr,_("%s: invalid fsync interval \"%s\"\n"),

progname,optarg);

exit(1);

}

break;

case'v':

verbose++;

break;

case2:

do_drop_slot= true;

break;

case3:

synchronous= true;

break;

default:

staticboolreportFlushPosition= false;

staticXLogRecPtrlastFlushPosition=InvalidXLogRecPtr;

staticint64last_fsync=-1;/* timestamp of last WAL file flush */

staticboolstill_sending= true;/* feedback still needs to be sent? */

staticPGresult*HandleCopyStream(PGconn*conn,XLogRecPtrstartpos,

uint32timeline,char*basedir,

stream_stop_callbackstream_stop,intstandby_message_timeout,

char*partial_suffix,XLogRecPtr*stoppos,

intfsync_interval);

boolsynchronous);

staticintCopyStreamPoll(PGconn*conn,longtimeout_ms);

staticintCopyStreamReceive(PGconn*conn,longtimeout,char**buffer);

staticboolProcessKeepaliveMsg(PGconn*conn,char*copybuf,intlen,

stream_stop_callbackstream_stop,

char*partial_suffix,XLogRecPtr*stoppos);

staticlongCalculateCopyStreamSleeptime(int64now,intstandby_message_timeout,

int64last_status,intfsync_interval,

XLogRecPtrblockpos);

int64last_status);

staticboolReadEndOfStreamingResult(PGresult*res,XLogRecPtr*startpos,

uint32*timeline);

progname,current_walfile_name,partial_suffix);

lastFlushPosition=pos;

last_fsync=feGetCurrentTimestamp();

return true;

}

char*sysidentifier,char*basedir,

stream_stop_callbackstream_stop,

intstandby_message_timeout,char*partial_suffix,

intfsync_interval)

boolsynchronous)

{

charquery[128];

charslotcmd[128];

res=HandleCopyStream(conn,startpos,timeline,basedir,stream_stop,

standby_message_timeout,partial_suffix,

&stoppos,fsync_interval);

&stoppos,synchronous);

if (res==NULL)

gotoerror;

HandleCopyStream(PGconn*conn,XLogRecPtrstartpos,uint32timeline,

char*basedir,stream_stop_callbackstream_stop,

intstandby_message_timeout,char*partial_suffix,

XLogRecPtr*stoppos,intfsync_interval)

XLogRecPtr*stoppos,boolsynchronous)

{

char*copybuf=NULL;

int64last_status=-1;

now=feGetCurrentTimestamp();

if (lastFlushPosition<blockpos&&

((fsync_interval>0&&

feTimestampDifferenceExceeds(last_fsync,now,fsync_interval))||

fsync_interval<0))

if (synchronous&&lastFlushPosition<blockpos&&walfile!=-1)

{

if (fsync(walfile)!=0)

{

fprintf(stderr,_("%s: could not fsync file \"%s\": %s\n"),

progname,current_walfile_name,strerror(errno));

gotoerror;

}

lastFlushPosition=blockpos;

last_fsync=now;

if (!sendFeedback(conn,blockpos,now, false))

gotoerror;

last_status=now;

}

sleeptime=CalculateCopyStreamSleeptime(now,standby_message_timeout,

last_status,fsync_interval,blockpos);

last_status);

r=CopyStreamReceive(conn,sleeptime,&copybuf);

while (r!=0)

CalculateCopyStreamSleeptime(int64now,intstandby_message_timeout,

int64last_status,intfsync_interval,XLogRecPtrblockpos)

int64last_status)

{

int64targettime=0;

int64status_targettime=0;

int64fsync_targettime=0;

longsleeptime;

if (standby_message_timeout&&still_sending)

(standby_message_timeout-1)* ((int64)1000);

if (fsync_interval>0&&lastFlushPosition<blockpos)

(fsync_interval-1)* ((int64)1000);

if ((status_targettime<fsync_targettime&&status_targettime>0)||

fsync_targettime==0)

targettime=status_targettime;

targettime=fsync_targettime;

if (targettime>0)

if (status_targettime>0)

{

longsecs;

intusecs;

feTimestampDifference(now,

targettime,

status_targettime,

&secs,

&usecs);

stream_stop_callbackstream_stop,

intstandby_message_timeout,

char*partial_suffix,

intfsync_interval);

boolsynchronous);