PostgreSQL Source Code  git master
basebackup_progress.c File Reference
#include "postgres.h"
#include "commands/progress.h"
#include "miscadmin.h"
#include "replication/basebackup.h"
#include "replication/basebackup_sink.h"
#include "pgstat.h"
#include "storage/latch.h"
#include "utils/timestamp.h"
Include dependency graph for basebackup_progress.c:

Go to the source code of this file.

Functions

static void bbsink_progress_begin_backup (bbsink *sink)
 
static void bbsink_progress_archive_contents (bbsink *sink, size_t len)
 
static void bbsink_progress_end_archive (bbsink *sink)
 
bbsinkbbsink_progress_new (bbsink *next, bool estimate_backup_size)
 
void basebackup_progress_wait_checkpoint (void)
 
void basebackup_progress_estimate_backup_size (void)
 
void basebackup_progress_wait_wal_archive (bbsink_state *state)
 
void basebackup_progress_transfer_wal (void)
 
void basebackup_progress_done (void)
 

Variables

static const bbsink_ops bbsink_progress_ops
 

Function Documentation

◆ basebackup_progress_done()

void basebackup_progress_done ( void  )

Definition at line 243 of file basebackup_progress.c.

244 {
246 }
void pgstat_progress_end_command(void)

References pgstat_progress_end_command().

Referenced by perform_base_backup().

◆ basebackup_progress_estimate_backup_size()

void basebackup_progress_estimate_backup_size ( void  )

Definition at line 200 of file basebackup_progress.c.

201 {
204 }
void pgstat_progress_update_param(int index, int64 val)
#define PROGRESS_BASEBACKUP_PHASE_ESTIMATE_BACKUP_SIZE
Definition: progress.h:131
#define PROGRESS_BASEBACKUP_PHASE
Definition: progress.h:123

References pgstat_progress_update_param(), PROGRESS_BASEBACKUP_PHASE, and PROGRESS_BASEBACKUP_PHASE_ESTIMATE_BACKUP_SIZE.

Referenced by perform_base_backup().

◆ basebackup_progress_transfer_wal()

void basebackup_progress_transfer_wal ( void  )

◆ basebackup_progress_wait_checkpoint()

void basebackup_progress_wait_checkpoint ( void  )

◆ basebackup_progress_wait_wal_archive()

void basebackup_progress_wait_wal_archive ( bbsink_state state)

Definition at line 210 of file basebackup_progress.c.

211 {
212  const int index[] = {
215  };
216  int64 val[2];
217 
218  /*
219  * We report having finished all tablespaces at this point, even if the
220  * archive for the main tablespace is still open, because what's going to
221  * be added is WAL files, not files that are really from the main
222  * tablespace.
223  */
225  val[1] = list_length(state->tablespaces);
227 }
void pgstat_progress_update_multi_param(int nparam, const int *index, const int64 *val)
long val
Definition: informix.c:664
static int list_length(const List *l)
Definition: pg_list.h:149
#define PROGRESS_BASEBACKUP_PHASE_WAIT_WAL_ARCHIVE
Definition: progress.h:133
#define PROGRESS_BASEBACKUP_TBLSPC_STREAMED
Definition: progress.h:127
Definition: type.h:90
Definition: regguts.h:318

References list_length(), pgstat_progress_update_multi_param(), PROGRESS_BASEBACKUP_PHASE, PROGRESS_BASEBACKUP_PHASE_WAIT_WAL_ARCHIVE, PROGRESS_BASEBACKUP_TBLSPC_STREAMED, and val.

Referenced by perform_base_backup().

◆ bbsink_progress_archive_contents()

static void bbsink_progress_archive_contents ( bbsink sink,
size_t  len 
)
static

Definition at line 154 of file basebackup_progress.c.

155 {
156  bbsink_state *state = sink->bbs_state;
157  const int index[] = {
160  };
161  int64 val[2];
162  int nparam = 0;
163 
164  /* First update bbsink_state with # of bytes done. */
165  state->bytes_done += len;
166 
167  /* Now forward to next sink. */
169 
170  /* Prepare to set # of bytes done for command progress reporting. */
171  val[nparam++] = state->bytes_done;
172 
173  /*
174  * We may also want to update # of total bytes, to avoid overflowing past
175  * 100% or the full size. This may make the total size number change as we
176  * approach the end of the backup (the estimate will always be wrong if
177  * WAL is included), but that's better than having the done column be
178  * bigger than the total.
179  */
180  if (state->bytes_total_is_valid && state->bytes_done > state->bytes_total)
181  val[nparam++] = state->bytes_done;
182 
184 }
void bbsink_forward_archive_contents(bbsink *sink, size_t len)
const void size_t len
#define PROGRESS_BASEBACKUP_BACKUP_TOTAL
Definition: progress.h:124
#define PROGRESS_BASEBACKUP_BACKUP_STREAMED
Definition: progress.h:125
bbsink_state * bbs_state

References bbsink::bbs_state, bbsink_forward_archive_contents(), len, pgstat_progress_update_multi_param(), PROGRESS_BASEBACKUP_BACKUP_STREAMED, PROGRESS_BASEBACKUP_BACKUP_TOTAL, and val.

◆ bbsink_progress_begin_backup()

static void bbsink_progress_begin_backup ( bbsink sink)
static

Definition at line 88 of file basebackup_progress.c.

89 {
90  const int index[] = {
94  };
95  int64 val[3];
96 
97  /*
98  * Report that we are now streaming database files as a base backup. Also
99  * advertise the number of tablespaces, and, if known, the estimated total
100  * backup size.
101  */
103  if (sink->bbs_state->bytes_total_is_valid)
104  val[1] = sink->bbs_state->bytes_total;
105  else
106  val[1] = -1;
107  val[2] = list_length(sink->bbs_state->tablespaces);
109 
110  /* Delegate to next sink. */
112 }
void bbsink_forward_begin_backup(bbsink *sink)
#define PROGRESS_BASEBACKUP_TBLSPC_TOTAL
Definition: progress.h:126
#define PROGRESS_BASEBACKUP_PHASE_STREAM_BACKUP
Definition: progress.h:132
bool bytes_total_is_valid
uint64 bytes_total
List * tablespaces

References bbsink::bbs_state, bbsink_forward_begin_backup(), bbsink_state::bytes_total, bbsink_state::bytes_total_is_valid, list_length(), pgstat_progress_update_multi_param(), PROGRESS_BASEBACKUP_BACKUP_TOTAL, PROGRESS_BASEBACKUP_PHASE, PROGRESS_BASEBACKUP_PHASE_STREAM_BACKUP, PROGRESS_BASEBACKUP_TBLSPC_TOTAL, bbsink_state::tablespaces, and val.

◆ bbsink_progress_end_archive()

static void bbsink_progress_end_archive ( bbsink sink)
static

Definition at line 118 of file basebackup_progress.c.

119 {
120  /*
121  * We expect one archive per tablespace, so reaching the end of an archive
122  * also means reaching the end of a tablespace. (Some day we might have a
123  * reason to decouple these concepts.)
124  *
125  * If WAL is included in the backup, we'll mark the last tablespace
126  * complete before the last archive is complete, so we need a guard here
127  * to ensure that the number of tablespaces streamed doesn't exceed the
128  * total.
129  */
132  sink->bbs_state->tablespace_num + 1);
133 
134  /* Delegate to next sink. */
136 
137  /*
138  * This is a convenient place to update the bbsink_state's notion of which
139  * is the current tablespace. Note that the bbsink_state object is shared
140  * across all bbsink objects involved, but we're the outermost one and
141  * this is the very last thing we do.
142  */
143  sink->bbs_state->tablespace_num++;
144 }
void bbsink_forward_end_archive(bbsink *sink)

References bbsink::bbs_state, bbsink_forward_end_archive(), list_length(), pgstat_progress_update_param(), PROGRESS_BASEBACKUP_TBLSPC_STREAMED, bbsink_state::tablespace_num, and bbsink_state::tablespaces.

◆ bbsink_progress_new()

bbsink* bbsink_progress_new ( bbsink next,
bool  estimate_backup_size 
)

Definition at line 63 of file basebackup_progress.c.

64 {
65  bbsink *sink;
66 
67  Assert(next != NULL);
68 
69  sink = palloc0(sizeof(bbsink));
70  *((const bbsink_ops **) &sink->bbs_ops) = &bbsink_progress_ops;
71  sink->bbs_next = next;
72 
73  /*
74  * Report that a base backup is in progress, and set the total size of the
75  * backup to -1, which will get translated to NULL. If we're estimating
76  * the backup size, we'll insert the real estimate when we have it.
77  */
80 
81  return sink;
82 }
void pgstat_progress_start_command(ProgressCommandType cmdtype, Oid relid)
@ PROGRESS_COMMAND_BASEBACKUP
static const bbsink_ops bbsink_progress_ops
static int32 next
Definition: blutils.c:219
Assert(fmt[strlen(fmt) - 1] !='\n')
void * palloc0(Size size)
Definition: mcxt.c:1099
#define InvalidOid
Definition: postgres_ext.h:36
bbsink * bbs_next
const bbsink_ops * bbs_ops

References Assert(), bbsink::bbs_next, bbsink::bbs_ops, bbsink_progress_ops, InvalidOid, next, palloc0(), pgstat_progress_start_command(), pgstat_progress_update_param(), PROGRESS_BASEBACKUP_BACKUP_TOTAL, and PROGRESS_COMMAND_BASEBACKUP.

Referenced by SendBaseBackup().

Variable Documentation

◆ bbsink_progress_ops

const bbsink_ops bbsink_progress_ops
static
Initial value:
= {
.begin_archive = bbsink_forward_begin_archive,
.archive_contents = bbsink_progress_archive_contents,
.begin_manifest = bbsink_forward_begin_manifest,
.manifest_contents = bbsink_forward_manifest_contents,
.end_manifest = bbsink_forward_end_manifest,
}
static void bbsink_progress_end_archive(bbsink *sink)
static void bbsink_progress_begin_backup(bbsink *sink)
static void bbsink_progress_archive_contents(bbsink *sink, size_t len)
void bbsink_forward_begin_manifest(bbsink *sink)
void bbsink_forward_end_backup(bbsink *sink, XLogRecPtr endptr, TimeLineID endtli)
void bbsink_forward_cleanup(bbsink *sink)
void bbsink_forward_manifest_contents(bbsink *sink, size_t len)
void bbsink_forward_begin_archive(bbsink *sink, const char *archive_name)
void bbsink_forward_end_manifest(bbsink *sink)

Definition at line 46 of file basebackup_progress.c.

Referenced by bbsink_progress_new().