astreamer_inject.c File Reference

#include "postgres_fe.h"
#include "astreamer_inject.h"
#include "common/file_perm.h"
#include "common/logging.h"

Include dependency graph for astreamer_inject.c:

Go to the source code of this file.

Data Structures
struct	astreamer_recovery_injector

Typedefs
typedef struct astreamer_recovery_injector	astreamer_recovery_injector

Functions
static void	astreamer_recovery_injector_content (astreamer *streamer, astreamer_member *member, const char *data, int len, astreamer_archive_context context)
static void	astreamer_recovery_injector_finalize (astreamer *streamer)
static void	astreamer_recovery_injector_free (astreamer *streamer)
astreamer *	astreamer_recovery_injector_new (astreamer *next, bool is_recovery_guc_supported, PQExpBuffer recoveryconfcontents)
void	astreamer_inject_file (astreamer *streamer, char *pathname, char *data, int len)

Variables
static const astreamer_ops	astreamer_recovery_injector_ops

Typedef Documentation

astreamer_recovery_injector

typedef struct astreamer_recovery_injector astreamer_recovery_injector

Function Documentation

astreamer_inject_file()

void astreamer_inject_file	(	astreamer *	streamer,
		char *	pathname,
		char *	data,
		int	len
	)

Definition at line 219 of file astreamer_inject.c.

{
    astreamer_member member;
 
    strlcpy(member.pathname, pathname, MAXPGPATH);
    member.size = len;
    member.mode = pg_file_create_mode;
    member.is_directory = false;
    member.is_link = false;
    member.linktarget[0] = '\0';
 
    /*
     * There seems to be no principled argument for these values, but they are
     * what PostgreSQL has historically used.
     */
    member.uid = 04000;
    member.gid = 02000;
 
    /*
     * We don't know here how to generate valid member headers and trailers
     * for the archiving format in use, so if those are needed, some successor
     * astreamer will have to generate them using the data from 'member'.
     */
    astreamer_content(streamer, &member, NULL, 0,
                      ASTREAMER_MEMBER_HEADER);
    astreamer_content(streamer, &member, data, len,
                      ASTREAMER_MEMBER_CONTENTS);
    astreamer_content(streamer, &member, NULL, 0,
                      ASTREAMER_MEMBER_TRAILER);
}

References astreamer_content(), ASTREAMER_MEMBER_CONTENTS, ASTREAMER_MEMBER_HEADER, ASTREAMER_MEMBER_TRAILER, data, astreamer_member::gid, astreamer_member::is_directory, astreamer_member::is_link, len, astreamer_member::linktarget, MAXPGPATH, astreamer_member::mode, astreamer_member::pathname, pg_file_create_mode, astreamer_member::size, strlcpy(), and astreamer_member::uid.

Referenced by astreamer_recovery_injector_content(), ReceiveArchiveStream(), and ReceiveTarFile().

astreamer_recovery_injector_content()

static void astreamer_recovery_injector_content ( astreamer *  streamer, astreamer_member *  member, const char *  data, int  len, astreamer_archive_context  context  )

static

Definition at line 85 of file astreamer_inject.c.

{
    astreamer_recovery_injector *mystreamer;
 
    mystreamer = (astreamer_recovery_injector *) streamer;
    Assert(member != NULL || context == ASTREAMER_ARCHIVE_TRAILER);
 
    switch (context)
    {
        case ASTREAMER_MEMBER_HEADER:
            /* Must copy provided data so we have the option to modify it. */
            memcpy(&mystreamer->member, member, sizeof(astreamer_member));
 
            /*
             * On v12+, skip standby.signal and edit postgresql.auto.conf; on
             * older versions, skip recovery.conf.
             */
            if (mystreamer->is_recovery_guc_supported)
            {
                mystreamer->skip_file =
                    (strcmp(member->pathname, "standby.signal") == 0);
                mystreamer->is_postgresql_auto_conf =
                    (strcmp(member->pathname, "postgresql.auto.conf") == 0);
                if (mystreamer->is_postgresql_auto_conf)
                {
                    /* Remember we saw it so we don't add it again. */
                    mystreamer->found_postgresql_auto_conf = true;
 
                    /* Increment length by data to be injected. */
                    mystreamer->member.size +=
                        mystreamer->recoveryconfcontents->len;
 
                    /*
                     * Zap data and len because the archive header is no
                     * longer valid; some subsequent astreamer must regenerate
                     * it if it's necessary.
                     */
                    data = NULL;
                    len = 0;
                }
            }
            else
                mystreamer->skip_file =
                    (strcmp(member->pathname, "recovery.conf") == 0);
 
            /* Do not forward if the file is to be skipped. */
            if (mystreamer->skip_file)
                return;
            break;
 
        case ASTREAMER_MEMBER_CONTENTS:
            /* Do not forward if the file is to be skipped. */
            if (mystreamer->skip_file)
                return;
            break;
 
        case ASTREAMER_MEMBER_TRAILER:
            /* Do not forward it the file is to be skipped. */
            if (mystreamer->skip_file)
                return;
 
            /* Append provided content to whatever we already sent. */
            if (mystreamer->is_postgresql_auto_conf)
                astreamer_content(mystreamer->base.bbs_next, member,
                                  mystreamer->recoveryconfcontents->data,
                                  mystreamer->recoveryconfcontents->len,
                                  ASTREAMER_MEMBER_CONTENTS);
            break;
 
        case ASTREAMER_ARCHIVE_TRAILER:
            if (mystreamer->is_recovery_guc_supported)
            {
                /*
                 * If we didn't already find (and thus modify)
                 * postgresql.auto.conf, inject it as an additional archive
                 * member now.
                 */
                if (!mystreamer->found_postgresql_auto_conf)
                    astreamer_inject_file(mystreamer->base.bbs_next,
                                          "postgresql.auto.conf",
                                          mystreamer->recoveryconfcontents->data,
                                          mystreamer->recoveryconfcontents->len);
 
                /* Inject empty standby.signal file. */
                astreamer_inject_file(mystreamer->base.bbs_next,
                                      "standby.signal", "", 0);
            }
            else
            {
                /* Inject recovery.conf file with specified contents. */
                astreamer_inject_file(mystreamer->base.bbs_next,
                                      "recovery.conf",
                                      mystreamer->recoveryconfcontents->data,
                                      mystreamer->recoveryconfcontents->len);
            }
 
            /* Nothing to do here. */
            break;
 
        default:
            /* Shouldn't happen. */
            pg_fatal("unexpected state while injecting recovery settings");
    }
 
    astreamer_content(mystreamer->base.bbs_next, &mystreamer->member,
                      data, len, context);
}

References Assert, ASTREAMER_ARCHIVE_TRAILER, astreamer_content(), astreamer_inject_file(), ASTREAMER_MEMBER_CONTENTS, ASTREAMER_MEMBER_HEADER, ASTREAMER_MEMBER_TRAILER, astreamer_recovery_injector::base, astreamer::bbs_next, context, PQExpBufferData::data, data, astreamer_recovery_injector::found_postgresql_auto_conf, astreamer_recovery_injector::is_postgresql_auto_conf, astreamer_recovery_injector::is_recovery_guc_supported, PQExpBufferData::len, len, astreamer_recovery_injector::member, astreamer_member::pathname, pg_fatal, astreamer_recovery_injector::recoveryconfcontents, astreamer_member::size, and astreamer_recovery_injector::skip_file.

astreamer_recovery_injector_finalize()

static void astreamer_recovery_injector_finalize ( astreamer *  streamer )

static

Definition at line 200 of file astreamer_inject.c.

{
    astreamer_finalize(streamer->bbs_next);
}

References astreamer_finalize(), and astreamer::bbs_next.

astreamer_recovery_injector_free()

static void astreamer_recovery_injector_free ( astreamer *  streamer )

static

Definition at line 209 of file astreamer_inject.c.

{
    astreamer_free(streamer->bbs_next);
    pfree(streamer);
}

References astreamer_free(), astreamer::bbs_next, and pfree().

astreamer_recovery_injector_new()

astreamer* astreamer_recovery_injector_new	(	astreamer *	next,
		bool	is_recovery_guc_supported,
		PQExpBuffer	recoveryconfcontents
	)

Definition at line 65 of file astreamer_inject.c.

{
    astreamer_recovery_injector *streamer;
 
    streamer = palloc0(sizeof(astreamer_recovery_injector));
    *((const astreamer_ops **) &streamer->base.bbs_ops) =
        &astreamer_recovery_injector_ops;
    streamer->base.bbs_next = next;
    streamer->is_recovery_guc_supported = is_recovery_guc_supported;
    streamer->recoveryconfcontents = recoveryconfcontents;
 
    return &streamer->base;
}

References astreamer_recovery_injector_ops, astreamer_recovery_injector::base, astreamer::bbs_next, astreamer::bbs_ops, astreamer_recovery_injector::is_recovery_guc_supported, next, palloc0(), astreamer_recovery_injector::recoveryconfcontents, and recoveryconfcontents.

Referenced by CreateBackupStreamer().

Variable Documentation

astreamer_recovery_injector_ops

const astreamer_ops astreamer_recovery_injector_ops

static

Initial value:

= {
    .content = astreamer_recovery_injector_content,
    .finalize = astreamer_recovery_injector_finalize,
    .free = astreamer_recovery_injector_free
}

Definition at line 36 of file astreamer_inject.c.

Referenced by astreamer_recovery_injector_new().