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, bool incremental)
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 36 of file basebackup_sink.h.

bbsink_ops

typedef struct bbsink_ops bbsink_ops

Definition at line 37 of file basebackup_sink.h.

bbsink_state

typedef struct bbsink_state bbsink_state

Function Documentation

basebackup_progress_done()

void basebackup_progress_done ( void  )

extern

Definition at line 244 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  )

extern

Definition at line 201 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  )

extern

Definition at line 234 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  )

extern

Definition at line 191 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 )

extern

Definition at line 211 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 Assert, fb(), 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, and fb().

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, and fb().

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, and fb().

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, and fb().

Referenced by bbsink_forward_cleanup(), and SendBaseBackup().

bbsink_copystream_new()

bbsink * bbsink_copystream_new ( bool  send_to_client )

extern

Definition at line 108 of file basebackup_copy.c.

{
    bbsink_copystream *sink = palloc0_object(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_ops, fb(), GetCurrentTimestamp(), palloc0_object, and UINT64CONST.

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, and fb().

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, fb(), and list_length().

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, and fb().

Referenced by bbsink_forward_end_manifest(), and SendBackupManifest().

bbsink_forward_archive_contents()

void bbsink_forward_archive_contents ( bbsink *  sink, size_t  len  )

extern

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_archive_contents(), fb(), 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  )

extern

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_begin_archive(), and fb().

Referenced by bbsink_server_begin_archive(), and bbsink_shell_begin_archive().

bbsink_forward_begin_backup()

void bbsink_forward_begin_backup ( bbsink *  sink )

extern

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_begin_backup(), and fb().

Referenced by bbsink_progress_begin_backup(), and bbsink_throttle_begin_backup().

bbsink_forward_begin_manifest()

void bbsink_forward_begin_manifest ( bbsink *  sink )

extern

Definition at line 76 of file basebackup_sink.c.

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

References Assert, bbsink_begin_manifest(), and fb().

Referenced by bbsink_server_begin_manifest(), and bbsink_shell_begin_manifest().

bbsink_forward_cleanup()

void bbsink_forward_cleanup ( bbsink *  sink )

extern

Definition at line 121 of file basebackup_sink.c.

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

References Assert, bbsink_cleanup(), and fb().

bbsink_forward_end_archive()

void bbsink_forward_end_archive ( bbsink *  sink )

extern

Definition at line 66 of file basebackup_sink.c.

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

References Assert, bbsink_end_archive(), and fb().

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  )

extern

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_end_backup(), and fb().

bbsink_forward_end_manifest()

void bbsink_forward_end_manifest ( bbsink *  sink )

extern

Definition at line 101 of file basebackup_sink.c.

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

References Assert, bbsink_end_manifest(), and fb().

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  )

extern

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_manifest_contents(), fb(), 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  )

extern

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_object(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, fb(), pg_compress_specification::level, next, and palloc0_object.

Referenced by SendBaseBackup().

bbsink_lz4_new()

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

extern

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_object(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, fb(), pg_compress_specification::level, next, and palloc0_object.

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, fb(), and len.

Referenced by bbsink_forward_manifest_contents(), and SendBackupManifest().

bbsink_progress_new()

bbsink * bbsink_progress_new ( bbsink *  next, bool  estimate_backup_size, bool  incremental  )

extern

Definition at line 59 of file basebackup_progress.c.

{
    bbsink     *sink;
 
    Assert(next != NULL);
 
    sink = palloc0_object(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. Also,
     * the backup type is set.
     */
    pgstat_progress_start_command(PROGRESS_COMMAND_BASEBACKUP, InvalidOid);
    pgstat_progress_update_param(PROGRESS_BASEBACKUP_BACKUP_TOTAL, -1);
    pgstat_progress_update_param(PROGRESS_BASEBACKUP_BACKUP_TYPE,
                                 incremental
                                 ? PROGRESS_BASEBACKUP_BACKUP_TYPE_INCREMENTAL
                                 : PROGRESS_BASEBACKUP_BACKUP_TYPE_FULL);
 
    return sink;
}

References Assert, bbsink_progress_ops, fb(), InvalidOid, next, palloc0_object, pgstat_progress_start_command(), pgstat_progress_update_param(), PROGRESS_BASEBACKUP_BACKUP_TOTAL, PROGRESS_BASEBACKUP_BACKUP_TYPE, PROGRESS_BASEBACKUP_BACKUP_TYPE_FULL, PROGRESS_BASEBACKUP_BACKUP_TYPE_INCREMENTAL, and PROGRESS_COMMAND_BASEBACKUP.

Referenced by SendBaseBackup().

bbsink_server_new()

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

extern

Definition at line 60 of file basebackup_server.c.

{
    bbsink_server *sink = palloc0_object(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_ops, CommitTransactionCommand(), ereport, errcode(), errcode_for_file_access(), errdetail(), errmsg(), ERROR, fb(), GetUserId(), has_privs_of_role(), is_absolute_path, MakePGDirectory(), next, palloc0_object, pg_check_dir(), and StartTransactionCommand().

Referenced by server_get_sink().

bbsink_throttle_new()

bbsink * bbsink_throttle_new ( bbsink *  next, uint32  maxrate  )

extern

Definition at line 68 of file basebackup_throttle.c.

{
    bbsink_throttle *sink;
 
    Assert(next != NULL);
    Assert(maxrate > 0);
 
    sink = palloc0_object(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_ops, fb(), maxrate, next, palloc0_object, THROTTLING_FREQUENCY, and USECS_PER_SEC.

Referenced by SendBaseBackup().

bbsink_zstd_new()

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

extern

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_object(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, fb(), next, and palloc0_object.

Referenced by SendBaseBackup().