basebackup_sink.h File Reference

#include "access/xlogdefs.h"
#include "common/compression.h"
#include "nodes/pg_list.h"

Include dependency graph for basebackup_sink.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	bbsink_state
struct	bbsink
struct	bbsink_ops

Typedefs
typedef struct bbsink	bbsink
typedef struct bbsink_ops	bbsink_ops
typedef struct bbsink_state	bbsink_state

Functions
static void	bbsink_begin_backup (bbsink *sink, bbsink_state *state, int buffer_length)
static void	bbsink_begin_archive (bbsink *sink, const char *archive_name)
static void	bbsink_archive_contents (bbsink *sink, size_t len)
static void	bbsink_end_archive (bbsink *sink)
static void	bbsink_begin_manifest (bbsink *sink)
static void	bbsink_manifest_contents (bbsink *sink, size_t len)
static void	bbsink_end_manifest (bbsink *sink)
static void	bbsink_end_backup (bbsink *sink, XLogRecPtr endptr, TimeLineID endtli)
static void	bbsink_cleanup (bbsink *sink)
void	bbsink_forward_begin_backup (bbsink *sink)
void	bbsink_forward_begin_archive (bbsink *sink, const char *archive_name)
void	bbsink_forward_archive_contents (bbsink *sink, size_t len)
void	bbsink_forward_end_archive (bbsink *sink)
void	bbsink_forward_begin_manifest (bbsink *sink)
void	bbsink_forward_manifest_contents (bbsink *sink, size_t len)
void	bbsink_forward_end_manifest (bbsink *sink)
void	bbsink_forward_end_backup (bbsink *sink, XLogRecPtr endptr, TimeLineID endtli)
void	bbsink_forward_cleanup (bbsink *sink)
bbsink *	bbsink_copystream_new (bool send_to_client)
bbsink *	bbsink_gzip_new (bbsink *next, pg_compress_specification *)
bbsink *	bbsink_lz4_new (bbsink *next, pg_compress_specification *)
bbsink *	bbsink_zstd_new (bbsink *next, pg_compress_specification *)
bbsink *	bbsink_progress_new (bbsink *next, bool estimate_backup_size)
bbsink *	bbsink_server_new (bbsink *next, char *pathname)
bbsink *	bbsink_throttle_new (bbsink *next, uint32 maxrate)
void	basebackup_progress_wait_checkpoint (void)
void	basebackup_progress_estimate_backup_size (void)
void	basebackup_progress_wait_wal_archive (bbsink_state *)
void	basebackup_progress_transfer_wal (void)
void	basebackup_progress_done (void)

Typedef Documentation

bbsink

typedef struct bbsink bbsink

Definition at line 1 of file basebackup_sink.h.

bbsink_ops

typedef struct bbsink_ops bbsink_ops

Definition at line 1 of file basebackup_sink.h.

bbsink_state

typedef struct bbsink_state bbsink_state

Function Documentation

basebackup_progress_done()

void basebackup_progress_done

(

void

)

Definition at line 239 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 196 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 229 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 186 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 206 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_archive_contents()

static void bbsink_archive_contents ( bbsink *  sink, size_t  len  )

inlinestatic

Definition at line 200 of file basebackup_sink.h.

{
    Assert(sink != NULL);
 
    /*
     * The caller should make a reasonable attempt to fill the buffer before
     * calling this function, so it shouldn't be completely empty. Nor should
     * it be filled beyond capacity.
     */
    Assert(len > 0 && len <= sink->bbs_buffer_length);
 
    sink->bbs_ops->archive_contents(sink, len);
}

References bbsink_ops::archive_contents, Assert, bbsink::bbs_ops, and len.

Referenced by _tarWriteHeader(), _tarWritePadding(), bbsink_forward_archive_contents(), perform_base_backup(), push_to_sink(), sendFile(), and sendFileWithContent().

bbsink_begin_archive()

static void bbsink_begin_archive ( bbsink *  sink, const char *  archive_name  )

inlinestatic

Definition at line 191 of file basebackup_sink.h.

{
    Assert(sink != NULL);
 
    sink->bbs_ops->begin_archive(sink, archive_name);
}

References Assert, bbsink::bbs_ops, and bbsink_ops::begin_archive.

Referenced by bbsink_forward_begin_archive(), and perform_base_backup().

bbsink_begin_backup()

static void bbsink_begin_backup ( bbsink *  sink, bbsink_state *  state, int  buffer_length  )

inlinestatic

Definition at line 175 of file basebackup_sink.h.

{
    Assert(sink != NULL);
 
    Assert(buffer_length > 0);
 
    sink->bbs_state = state;
    sink->bbs_buffer_length = buffer_length;
    sink->bbs_ops->begin_backup(sink);
 
    Assert(sink->bbs_buffer != NULL);
    Assert((sink->bbs_buffer_length % BLCKSZ) == 0);
}

References Assert, bbsink::bbs_buffer, bbsink::bbs_buffer_length, bbsink::bbs_ops, bbsink::bbs_state, and bbsink_ops::begin_backup.

Referenced by bbsink_forward_begin_backup(), and perform_base_backup().

bbsink_begin_manifest()

static void bbsink_begin_manifest ( bbsink *  sink )

inlinestatic

Definition at line 225 of file basebackup_sink.h.

{
    Assert(sink != NULL);
 
    sink->bbs_ops->begin_manifest(sink);
}

References Assert, bbsink::bbs_ops, and bbsink_ops::begin_manifest.

Referenced by bbsink_forward_begin_manifest(), and SendBackupManifest().

bbsink_cleanup()

static void bbsink_cleanup ( bbsink *  sink )

inlinestatic

Definition at line 265 of file basebackup_sink.h.

{
    Assert(sink != NULL);
 
    sink->bbs_ops->cleanup(sink);
}

References Assert, bbsink::bbs_ops, and bbsink_ops::cleanup.

Referenced by bbsink_forward_cleanup(), and SendBaseBackup().

bbsink_copystream_new()

bbsink* bbsink_copystream_new

(

bool

send_to_client

)

Definition at line 108 of file basebackup_copy.c.

{
    bbsink_copystream *sink = palloc0(sizeof(bbsink_copystream));
 
    *((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_copystream_ops;
    sink->send_to_client = send_to_client;
 
    /* Set up for periodic progress reporting. */
    sink->last_progress_report_time = GetCurrentTimestamp();
    sink->bytes_done_at_last_time_check = UINT64CONST(0);
 
    return &sink->base;
}

References bbsink_copystream::base, bbsink::bbs_ops, bbsink_copystream_ops, bbsink_copystream::bytes_done_at_last_time_check, GetCurrentTimestamp(), bbsink_copystream::last_progress_report_time, palloc0(), and bbsink_copystream::send_to_client.

Referenced by SendBaseBackup().

bbsink_end_archive()

static void bbsink_end_archive ( bbsink *  sink )

inlinestatic

Definition at line 216 of file basebackup_sink.h.

{
    Assert(sink != NULL);
 
    sink->bbs_ops->end_archive(sink);
}

References Assert, bbsink::bbs_ops, and bbsink_ops::end_archive.

Referenced by bbsink_forward_end_archive(), and perform_base_backup().

bbsink_end_backup()

static void bbsink_end_backup ( bbsink *  sink, XLogRecPtr  endptr, TimeLineID  endtli  )

inlinestatic

Definition at line 255 of file basebackup_sink.h.

{
    Assert(sink != NULL);
    Assert(sink->bbs_state->tablespace_num == list_length(sink->bbs_state->tablespaces));
 
    sink->bbs_ops->end_backup(sink, endptr, endtli);
}

References Assert, bbsink::bbs_ops, bbsink::bbs_state, bbsink_ops::end_backup, list_length(), bbsink_state::tablespace_num, and bbsink_state::tablespaces.

Referenced by bbsink_forward_end_backup(), and perform_base_backup().

bbsink_end_manifest()

static void bbsink_end_manifest ( bbsink *  sink )

inlinestatic

Definition at line 246 of file basebackup_sink.h.

{
    Assert(sink != NULL);
 
    sink->bbs_ops->end_manifest(sink);
}

References Assert, bbsink::bbs_ops, and bbsink_ops::end_manifest.

Referenced by bbsink_forward_end_manifest(), and SendBackupManifest().

bbsink_forward_archive_contents()

void bbsink_forward_archive_contents	(	bbsink *	sink,
		size_t	len
	)

Definition at line 54 of file basebackup_sink.c.

{
    Assert(sink->bbs_next != NULL);
    Assert(sink->bbs_buffer == sink->bbs_next->bbs_buffer);
    Assert(sink->bbs_buffer_length == sink->bbs_next->bbs_buffer_length);
    bbsink_archive_contents(sink->bbs_next, len);
}

References Assert, bbsink::bbs_buffer, bbsink::bbs_buffer_length, bbsink::bbs_next, bbsink_archive_contents(), and len.

Referenced by bbsink_progress_archive_contents(), bbsink_server_archive_contents(), bbsink_shell_archive_contents(), and bbsink_throttle_archive_contents().

bbsink_forward_begin_archive()

void bbsink_forward_begin_archive	(	bbsink *	sink,
		const char *	archive_name
	)

Definition at line 37 of file basebackup_sink.c.

{
    Assert(sink->bbs_next != NULL);
    bbsink_begin_archive(sink->bbs_next, archive_name);
}

References Assert, bbsink::bbs_next, and bbsink_begin_archive().

Referenced by bbsink_server_begin_archive(), and bbsink_shell_begin_archive().

bbsink_forward_begin_backup()

void bbsink_forward_begin_backup

(

bbsink *

sink

)

Definition at line 24 of file basebackup_sink.c.

{
    Assert(sink->bbs_next != NULL);
    Assert(sink->bbs_state != NULL);
    bbsink_begin_backup(sink->bbs_next, sink->bbs_state,
                        sink->bbs_buffer_length);
    sink->bbs_buffer = sink->bbs_next->bbs_buffer;
}

References Assert, bbsink::bbs_buffer, bbsink::bbs_buffer_length, bbsink::bbs_next, bbsink::bbs_state, and bbsink_begin_backup().

Referenced by bbsink_progress_begin_backup(), and bbsink_throttle_begin_backup().

bbsink_forward_begin_manifest()

void bbsink_forward_begin_manifest

(

bbsink *

sink

)

Definition at line 76 of file basebackup_sink.c.

{
    Assert(sink->bbs_next != NULL);
    bbsink_begin_manifest(sink->bbs_next);
}

References Assert, bbsink::bbs_next, and bbsink_begin_manifest().

Referenced by bbsink_server_begin_manifest(), and bbsink_shell_begin_manifest().

bbsink_forward_cleanup()

void bbsink_forward_cleanup

(

bbsink *

sink

)

Definition at line 121 of file basebackup_sink.c.

{
    Assert(sink->bbs_next != NULL);
    bbsink_cleanup(sink->bbs_next);
}

References Assert, bbsink::bbs_next, and bbsink_cleanup().

bbsink_forward_end_archive()

void bbsink_forward_end_archive

(

bbsink *

sink

)

Definition at line 66 of file basebackup_sink.c.

{
    Assert(sink->bbs_next != NULL);
    bbsink_end_archive(sink->bbs_next);
}

References Assert, bbsink::bbs_next, and bbsink_end_archive().

Referenced by bbsink_progress_end_archive(), bbsink_server_end_archive(), and bbsink_shell_end_archive().

bbsink_forward_end_backup()

void bbsink_forward_end_backup	(	bbsink *	sink,
		XLogRecPtr	endptr,
		TimeLineID	endtli
	)

Definition at line 111 of file basebackup_sink.c.

{
    Assert(sink->bbs_next != NULL);
    bbsink_end_backup(sink->bbs_next, endptr, endtli);
}

References Assert, bbsink::bbs_next, and bbsink_end_backup().

bbsink_forward_end_manifest()

void bbsink_forward_end_manifest

(

bbsink *

sink

)

Definition at line 101 of file basebackup_sink.c.

{
    Assert(sink->bbs_next != NULL);
    bbsink_end_manifest(sink->bbs_next);
}

References Assert, bbsink::bbs_next, and bbsink_end_manifest().

Referenced by bbsink_server_end_manifest(), and bbsink_shell_end_manifest().

bbsink_forward_manifest_contents()

void bbsink_forward_manifest_contents	(	bbsink *	sink,
		size_t	len
	)

Definition at line 89 of file basebackup_sink.c.

{
    Assert(sink->bbs_next != NULL);
    Assert(sink->bbs_buffer == sink->bbs_next->bbs_buffer);
    Assert(sink->bbs_buffer_length == sink->bbs_next->bbs_buffer_length);
    bbsink_manifest_contents(sink->bbs_next, len);
}

References Assert, bbsink::bbs_buffer, bbsink::bbs_buffer_length, bbsink::bbs_next, bbsink_manifest_contents(), and len.

Referenced by bbsink_server_manifest_contents(), bbsink_shell_manifest_contents(), and bbsink_throttle_manifest_contents().

bbsink_gzip_new()

bbsink* bbsink_gzip_new	(	bbsink *	next,
		pg_compress_specification *	compress
	)

Definition at line 62 of file basebackup_gzip.c.

{
#ifndef HAVE_LIBZ
    ereport(ERROR,
            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             errmsg("gzip compression is not supported by this build")));
    return NULL;                /* keep compiler quiet */
#else
    bbsink_gzip *sink;
    int         compresslevel;
 
    Assert(next != NULL);
 
    compresslevel = compress->level;
    Assert((compresslevel >= 1 && compresslevel <= 9) ||
           compresslevel == Z_DEFAULT_COMPRESSION);
 
    sink = palloc0(sizeof(bbsink_gzip));
    *((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_gzip_ops;
    sink->base.bbs_next = next;
    sink->compresslevel = compresslevel;
 
    return &sink->base;
#endif
}

References Assert, compresslevel, ereport, errcode(), errmsg(), ERROR, pg_compress_specification::level, next, and palloc0().

Referenced by SendBaseBackup().

bbsink_lz4_new()

bbsink* bbsink_lz4_new	(	bbsink *	next,
		pg_compress_specification *	compress
	)

Definition at line 62 of file basebackup_lz4.c.

{
#ifndef USE_LZ4
    ereport(ERROR,
            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             errmsg("lz4 compression is not supported by this build")));
    return NULL;                /* keep compiler quiet */
#else
    bbsink_lz4 *sink;
    int         compresslevel;
 
    Assert(next != NULL);
 
    compresslevel = compress->level;
    Assert(compresslevel >= 0 && compresslevel <= 12);
 
    sink = palloc0(sizeof(bbsink_lz4));
    *((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_lz4_ops;
    sink->base.bbs_next = next;
    sink->compresslevel = compresslevel;
 
    return &sink->base;
#endif
}

References Assert, compresslevel, ereport, errcode(), errmsg(), ERROR, pg_compress_specification::level, next, and palloc0().

Referenced by SendBaseBackup().

bbsink_manifest_contents()

static void bbsink_manifest_contents ( bbsink *  sink, size_t  len  )

inlinestatic

Definition at line 234 of file basebackup_sink.h.

{
    Assert(sink != NULL);
 
    /* See comments in bbsink_archive_contents. */
    Assert(len > 0 && len <= sink->bbs_buffer_length);
 
    sink->bbs_ops->manifest_contents(sink, len);
}

References Assert, bbsink::bbs_ops, len, and bbsink_ops::manifest_contents.

Referenced by bbsink_forward_manifest_contents(), and SendBackupManifest().

bbsink_progress_new()

bbsink* bbsink_progress_new	(	bbsink *	next,
		bool	estimate_backup_size
	)

Definition at line 59 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().

bbsink_server_new()

bbsink* bbsink_server_new	(	bbsink *	next,
		char *	pathname
	)

Definition at line 60 of file basebackup_server.c.

{
    bbsink_server *sink = palloc0(sizeof(bbsink_server));
 
    *((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_server_ops;
    sink->pathname = pathname;
    sink->base.bbs_next = next;
 
    /* Replication permission is not sufficient in this case. */
    StartTransactionCommand();
    if (!has_privs_of_role(GetUserId(), ROLE_PG_WRITE_SERVER_FILES))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to create backup stored on server"),
                 errdetail("Only roles with privileges of the \"%s\" role may create a backup stored on the server.",
                           "pg_write_server_files")));
    CommitTransactionCommand();
 
    /*
     * It's not a good idea to store your backups in the same directory that
     * you're backing up. If we allowed a relative path here, that could
     * easily happen accidentally, so we don't. The user could still
     * accomplish the same thing by including the absolute path to $PGDATA in
     * the pathname, but that's likely an intentional bad decision rather than
     * an accident.
     */
    if (!is_absolute_path(pathname))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("relative path not allowed for backup stored on server")));
 
    switch (pg_check_dir(pathname))
    {
        case 0:
 
            /*
             * Does not exist, so create it using the same permissions we'd
             * use for a new subdirectory of the data directory itself.
             */
            if (MakePGDirectory(pathname) < 0)
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not create directory \"%s\": %m", pathname)));
            break;
 
        case 1:
            /* Exists, empty. */
            break;
 
        case 2:
        case 3:
        case 4:
            /* Exists, not empty. */
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_FILE),
                     errmsg("directory \"%s\" exists but is not empty",
                            pathname)));
            break;
 
        default:
            /* Access problem. */
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not access directory \"%s\": %m",
                            pathname)));
    }
 
    return &sink->base;
}

References bbsink_server::base, bbsink::bbs_next, bbsink::bbs_ops, bbsink_server_ops, CommitTransactionCommand(), ereport, errcode(), errcode_for_file_access(), errdetail(), errmsg(), ERROR, GetUserId(), has_privs_of_role(), is_absolute_path, MakePGDirectory(), next, palloc0(), bbsink_server::pathname, pg_check_dir(), and StartTransactionCommand().

Referenced by server_get_sink().

bbsink_throttle_new()

bbsink* bbsink_throttle_new	(	bbsink *	next,
		uint32	maxrate
	)

Definition at line 68 of file basebackup_throttle.c.

{
    bbsink_throttle *sink;
 
    Assert(next != NULL);
    Assert(maxrate > 0);
 
    sink = palloc0(sizeof(bbsink_throttle));
    *((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_throttle_ops;
    sink->base.bbs_next = next;
 
    sink->throttling_sample =
        (int64) maxrate * (int64) 1024 / THROTTLING_FREQUENCY;
 
    /*
     * The minimum amount of time for throttling_sample bytes to be
     * transferred.
     */
    sink->elapsed_min_unit = USECS_PER_SEC / THROTTLING_FREQUENCY;
 
    return &sink->base;
}

References Assert, bbsink_throttle::base, bbsink::bbs_next, bbsink::bbs_ops, bbsink_throttle_ops, bbsink_throttle::elapsed_min_unit, maxrate, next, palloc0(), THROTTLING_FREQUENCY, bbsink_throttle::throttling_sample, and USECS_PER_SEC.

Referenced by SendBaseBackup().

bbsink_zstd_new()

bbsink* bbsink_zstd_new	(	bbsink *	next,
		pg_compress_specification *	compress
	)

Definition at line 61 of file basebackup_zstd.c.

{
#ifndef USE_ZSTD
    ereport(ERROR,
            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             errmsg("zstd compression is not supported by this build")));
    return NULL;                /* keep compiler quiet */
#else
    bbsink_zstd *sink;
 
    Assert(next != NULL);
 
    sink = palloc0(sizeof(bbsink_zstd));
    *((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_zstd_ops;
    sink->base.bbs_next = next;
    sink->compress = compress;
 
    return &sink->base;
#endif
}

References Assert, ereport, errcode(), errmsg(), ERROR, next, and palloc0().

Referenced by SendBaseBackup().