basebackup_progress.c File Reference

#include "postgres.h"
#include "backup/basebackup.h"
#include "backup/basebackup_sink.h"
#include "commands/progress.h"
#include "miscadmin.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)
bbsink *	bbsink_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.

{
    pgstat_progress_end_command();
}

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.

{
    pgstat_progress_update_param(PROGRESS_BASEBACKUP_PHASE,
                                 PROGRESS_BASEBACKUP_PHASE_ESTIMATE_BACKUP_SIZE);
}

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

)

Definition at line 233 of file basebackup_progress.c.

{
    pgstat_progress_update_param(PROGRESS_BASEBACKUP_PHASE,
                                 PROGRESS_BASEBACKUP_PHASE_TRANSFER_WAL);
}

References pgstat_progress_update_param(), PROGRESS_BASEBACKUP_PHASE, and PROGRESS_BASEBACKUP_PHASE_TRANSFER_WAL.

Referenced by perform_base_backup().

basebackup_progress_wait_checkpoint()

void basebackup_progress_wait_checkpoint

(

void

)

Definition at line 190 of file basebackup_progress.c.

{
    pgstat_progress_update_param(PROGRESS_BASEBACKUP_PHASE,
                                 PROGRESS_BASEBACKUP_PHASE_WAIT_CHECKPOINT);
}

References pgstat_progress_update_param(), PROGRESS_BASEBACKUP_PHASE, and PROGRESS_BASEBACKUP_PHASE_WAIT_CHECKPOINT.

Referenced by perform_base_backup().

basebackup_progress_wait_wal_archive()

void basebackup_progress_wait_wal_archive

(

bbsink_state *

state

)

Definition at line 210 of file basebackup_progress.c.

{
    const int   index[] = {
        PROGRESS_BASEBACKUP_PHASE,
        PROGRESS_BASEBACKUP_TBLSPC_STREAMED
    };
    int64       val[2];
 
    /*
     * We report having finished all tablespaces at this point, even if the
     * archive for the main tablespace is still open, because what's going to
     * be added is WAL files, not files that are really from the main
     * tablespace.
     */
    val[0] = PROGRESS_BASEBACKUP_PHASE_WAIT_WAL_ARCHIVE;
    val[1] = list_length(state->tablespaces);
    pgstat_progress_update_multi_param(2, index, val);
}

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.

{
    bbsink_state *state = sink->bbs_state;
    const int   index[] = {
        PROGRESS_BASEBACKUP_BACKUP_STREAMED,
        PROGRESS_BASEBACKUP_BACKUP_TOTAL
    };
    int64       val[2];
    int         nparam = 0;
 
    /* First update bbsink_state with # of bytes done. */
    state->bytes_done += len;
 
    /* Now forward to next sink. */
    bbsink_forward_archive_contents(sink, len);
 
    /* Prepare to set # of bytes done for command progress reporting. */
    val[nparam++] = state->bytes_done;
 
    /*
     * We may also want to update # of total bytes, to avoid overflowing past
     * 100% or the full size. This may make the total size number change as we
     * approach the end of the backup (the estimate will always be wrong if
     * WAL is included), but that's better than having the done column be
     * bigger than the total.
     */
    if (state->bytes_total_is_valid && state->bytes_done > state->bytes_total)
        val[nparam++] = state->bytes_done;
 
    pgstat_progress_update_multi_param(nparam, index, val);
}

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.

{
    const int   index[] = {
        PROGRESS_BASEBACKUP_PHASE,
        PROGRESS_BASEBACKUP_BACKUP_TOTAL,
        PROGRESS_BASEBACKUP_TBLSPC_TOTAL
    };
    int64       val[3];
 
    /*
     * Report that we are now streaming database files as a base backup. Also
     * advertise the number of tablespaces, and, if known, the estimated total
     * backup size.
     */
    val[0] = PROGRESS_BASEBACKUP_PHASE_STREAM_BACKUP;
    if (sink->bbs_state->bytes_total_is_valid)
        val[1] = sink->bbs_state->bytes_total;
    else
        val[1] = -1;
    val[2] = list_length(sink->bbs_state->tablespaces);
    pgstat_progress_update_multi_param(3, index, val);
 
    /* Delegate to next sink. */
    bbsink_forward_begin_backup(sink);
}

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.

{
    /*
     * We expect one archive per tablespace, so reaching the end of an archive
     * also means reaching the end of a tablespace. (Some day we might have a
     * reason to decouple these concepts.)
     *
     * If WAL is included in the backup, we'll mark the last tablespace
     * complete before the last archive is complete, so we need a guard here
     * to ensure that the number of tablespaces streamed doesn't exceed the
     * total.
     */
    if (sink->bbs_state->tablespace_num < list_length(sink->bbs_state->tablespaces))
        pgstat_progress_update_param(PROGRESS_BASEBACKUP_TBLSPC_STREAMED,
                                     sink->bbs_state->tablespace_num + 1);
 
    /* Delegate to next sink. */
    bbsink_forward_end_archive(sink);
 
    /*
     * This is a convenient place to update the bbsink_state's notion of which
     * is the current tablespace. Note that the bbsink_state object is shared
     * across all bbsink objects involved, but we're the outermost one and
     * this is the very last thing we do.
     */
    sink->bbs_state->tablespace_num++;
}

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.

{
    bbsink     *sink;
 
    Assert(next != NULL);
 
    sink = palloc0(sizeof(bbsink));
    *((const bbsink_ops **) &sink->bbs_ops) = &bbsink_progress_ops;
    sink->bbs_next = next;
 
    /*
     * Report that a base backup is in progress, and set the total size of the
     * backup to -1, which will get translated to NULL. If we're estimating
     * the backup size, we'll insert the real estimate when we have it.
     */
    pgstat_progress_start_command(PROGRESS_COMMAND_BASEBACKUP, InvalidOid);
    pgstat_progress_update_param(PROGRESS_BASEBACKUP_BACKUP_TOTAL, -1);
 
    return sink;
}

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_backup = bbsink_progress_begin_backup,
    .begin_archive = bbsink_forward_begin_archive,
    .archive_contents = bbsink_progress_archive_contents,
    .end_archive = bbsink_progress_end_archive,
    .begin_manifest = bbsink_forward_begin_manifest,
    .manifest_contents = bbsink_forward_manifest_contents,
    .end_manifest = bbsink_forward_end_manifest,
    .end_backup = bbsink_forward_end_backup,
    .cleanup = bbsink_forward_cleanup
}

Definition at line 46 of file basebackup_progress.c.

Referenced by bbsink_progress_new().