write_manifest.c File Reference

#include "postgres_fe.h"
#include <fcntl.h>
#include <time.h>
#include <unistd.h>
#include "common/checksum_helper.h"
#include "common/file_perm.h"
#include "common/logging.h"
#include "lib/stringinfo.h"
#include "load_manifest.h"
#include "mb/pg_wchar.h"
#include "write_manifest.h"

Include dependency graph for write_manifest.c:

Go to the source code of this file.

Data Structures
struct	manifest_writer

Functions
static void	escape_json (StringInfo buf, const char *str)
static void	flush_manifest (manifest_writer *mwriter)
static size_t	hex_encode (const uint8 *src, size_t len, char *dst)
manifest_writer *	create_manifest_writer (char *directory, uint64 system_identifier)
void	add_file_to_manifest (manifest_writer *mwriter, const char *manifest_path, size_t size, time_t mtime, pg_checksum_type checksum_type, int checksum_length, uint8 *checksum_payload)
void	finalize_manifest (manifest_writer *mwriter, manifest_wal_range *first_wal_range)

Function Documentation

add_file_to_manifest()

void add_file_to_manifest	(	manifest_writer *	mwriter,
		const char *	manifest_path,
		size_t	size,
		time_t	mtime,
		pg_checksum_type	checksum_type,
		int	checksum_length,
		uint8 *	checksum_payload
	)

Definition at line 76 of file write_manifest.c.

{
    int         pathlen = strlen(manifest_path);
 
    if (mwriter->first_file)
    {
        appendStringInfoChar(&mwriter->buf, '\n');
        mwriter->first_file = false;
    }
    else
        appendStringInfoString(&mwriter->buf, ",\n");
 
    if (pg_encoding_verifymbstr(PG_UTF8, manifest_path, pathlen) == pathlen)
    {
        appendStringInfoString(&mwriter->buf, "{ \"Path\": ");
        escape_json(&mwriter->buf, manifest_path);
        appendStringInfoString(&mwriter->buf, ", ");
    }
    else
    {
        appendStringInfoString(&mwriter->buf, "{ \"Encoded-Path\": \"");
        enlargeStringInfo(&mwriter->buf, 2 * pathlen);
        mwriter->buf.len += hex_encode((const uint8 *) manifest_path, pathlen,
                                       &mwriter->buf.data[mwriter->buf.len]);
        appendStringInfoString(&mwriter->buf, "\", ");
    }
 
    appendStringInfo(&mwriter->buf, "\"Size\": %zu, ", size);
 
    appendStringInfoString(&mwriter->buf, "\"Last-Modified\": \"");
    enlargeStringInfo(&mwriter->buf, 128);
    mwriter->buf.len += strftime(&mwriter->buf.data[mwriter->buf.len], 128,
                                 "%Y-%m-%d %H:%M:%S %Z",
                                 gmtime(&mtime));
    appendStringInfoChar(&mwriter->buf, '"');
 
    if (mwriter->buf.len > 128 * 1024)
        flush_manifest(mwriter);
 
    if (checksum_length > 0)
    {
        appendStringInfo(&mwriter->buf,
                         ", \"Checksum-Algorithm\": \"%s\", \"Checksum\": \"",
                         pg_checksum_type_name(checksum_type));
 
        enlargeStringInfo(&mwriter->buf, 2 * checksum_length);
        mwriter->buf.len += hex_encode(checksum_payload, checksum_length,
                                       &mwriter->buf.data[mwriter->buf.len]);
 
        appendStringInfoChar(&mwriter->buf, '"');
    }
 
    appendStringInfoString(&mwriter->buf, " }");
 
    if (mwriter->buf.len > 128 * 1024)
        flush_manifest(mwriter);
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), manifest_writer::buf, StringInfoData::data, enlargeStringInfo(), escape_json(), manifest_writer::first_file, flush_manifest(), hex_encode(), StringInfoData::len, pg_checksum_type_name(), pg_encoding_verifymbstr(), PG_UTF8, and size.

Referenced by process_directory_recursively(), and write_backup_label().

create_manifest_writer()

manifest_writer* create_manifest_writer	(	char *	directory,
		uint64	system_identifier
	)

Definition at line 48 of file write_manifest.c.

{
    manifest_writer *mwriter = pg_malloc(sizeof(manifest_writer));
 
    snprintf(mwriter->pathname, MAXPGPATH, "%s/backup_manifest", directory);
    mwriter->fd = -1;
    initStringInfo(&mwriter->buf);
    mwriter->first_file = true;
    mwriter->still_checksumming = true;
    pg_checksum_init(&mwriter->manifest_ctx, CHECKSUM_TYPE_SHA256);
 
    appendStringInfo(&mwriter->buf,
                     "{ \"PostgreSQL-Backup-Manifest-Version\": 2,\n"
                     "\"System-Identifier\": " UINT64_FORMAT ",\n"
                     "\"Files\": [",
                     system_identifier);
 
    return mwriter;
}

References appendStringInfo(), manifest_writer::buf, CHECKSUM_TYPE_SHA256, directory, manifest_writer::fd, manifest_writer::first_file, initStringInfo(), manifest_writer::manifest_ctx, MAXPGPATH, manifest_writer::pathname, pg_checksum_init(), pg_malloc(), snprintf, manifest_writer::still_checksumming, and UINT64_FORMAT.

Referenced by main().

escape_json()

static void escape_json ( StringInfo  buf, const char *  str  )

static

Definition at line 195 of file write_manifest.c.

{
    const char *p;
 
    appendStringInfoCharMacro(buf, '"');
    for (p = str; *p; p++)
    {
        switch (*p)
        {
            case '\b':
                appendStringInfoString(buf, "\\b");
                break;
            case '\f':
                appendStringInfoString(buf, "\\f");
                break;
            case '\n':
                appendStringInfoString(buf, "\\n");
                break;
            case '\r':
                appendStringInfoString(buf, "\\r");
                break;
            case '\t':
                appendStringInfoString(buf, "\\t");
                break;
            case '"':
                appendStringInfoString(buf, "\\\"");
                break;
            case '\\':
                appendStringInfoString(buf, "\\\\");
                break;
            default:
                if ((unsigned char) *p < ' ')
                    appendStringInfo(buf, "\\u%04x", (int) *p);
                else
                    appendStringInfoCharMacro(buf, *p);
                break;
        }
    }
    appendStringInfoCharMacro(buf, '"');
}

References appendStringInfo(), appendStringInfoCharMacro, appendStringInfoString(), buf, and str.

Referenced by add_file_to_manifest().

finalize_manifest()

void finalize_manifest	(	manifest_writer *	mwriter,
		manifest_wal_range *	first_wal_range
	)

Definition at line 142 of file write_manifest.c.

{
    uint8       checksumbuf[PG_SHA256_DIGEST_LENGTH];
    int         len;
    manifest_wal_range *wal_range;
 
    /* Terminate the list of files. */
    appendStringInfoString(&mwriter->buf, "\n],\n");
 
    /* Start a list of LSN ranges. */
    appendStringInfoString(&mwriter->buf, "\"WAL-Ranges\": [\n");
 
    for (wal_range = first_wal_range; wal_range != NULL;
         wal_range = wal_range->next)
        appendStringInfo(&mwriter->buf,
                         "%s{ \"Timeline\": %u, \"Start-LSN\": \"%X/%X\", \"End-LSN\": \"%X/%X\" }",
                         wal_range == first_wal_range ? "" : ",\n",
                         wal_range->tli,
                         LSN_FORMAT_ARGS(wal_range->start_lsn),
                         LSN_FORMAT_ARGS(wal_range->end_lsn));
 
    /* Terminate the list of WAL ranges. */
    appendStringInfoString(&mwriter->buf, "\n],\n");
 
    /* Flush accumulated data and update checksum calculation. */
    flush_manifest(mwriter);
 
    /* Checksum only includes data up to this point. */
    mwriter->still_checksumming = false;
 
    /* Compute and insert manifest checksum. */
    appendStringInfoString(&mwriter->buf, "\"Manifest-Checksum\": \"");
    enlargeStringInfo(&mwriter->buf, 2 * PG_SHA256_DIGEST_STRING_LENGTH);
    len = pg_checksum_final(&mwriter->manifest_ctx, checksumbuf);
    Assert(len == PG_SHA256_DIGEST_LENGTH);
    mwriter->buf.len +=
        hex_encode(checksumbuf, len, &mwriter->buf.data[mwriter->buf.len]);
    appendStringInfoString(&mwriter->buf, "\"}\n");
 
    /* Flush the last manifest checksum itself. */
    flush_manifest(mwriter);
 
    /* Close the file. */
    if (close(mwriter->fd) != 0)
        pg_fatal("could not close \"%s\": %m", mwriter->pathname);
    mwriter->fd = -1;
}

References appendStringInfo(), appendStringInfoString(), Assert, manifest_writer::buf, close, StringInfoData::data, manifest_wal_range::end_lsn, enlargeStringInfo(), manifest_writer::fd, flush_manifest(), hex_encode(), StringInfoData::len, len, LSN_FORMAT_ARGS, manifest_writer::manifest_ctx, manifest_wal_range::next, manifest_writer::pathname, pg_checksum_final(), pg_fatal, PG_SHA256_DIGEST_LENGTH, PG_SHA256_DIGEST_STRING_LENGTH, manifest_wal_range::start_lsn, manifest_writer::still_checksumming, and manifest_wal_range::tli.

Referenced by main().

flush_manifest()

static void flush_manifest ( manifest_writer *  mwriter )

static

Definition at line 244 of file write_manifest.c.

{
    if (mwriter->fd == -1 &&
        (mwriter->fd = open(mwriter->pathname,
                            O_WRONLY | O_CREAT | O_EXCL | PG_BINARY,
                            pg_file_create_mode)) < 0)
        pg_fatal("could not open file \"%s\": %m", mwriter->pathname);
 
    if (mwriter->buf.len > 0)
    {
        ssize_t     wb;
 
        wb = write(mwriter->fd, mwriter->buf.data, mwriter->buf.len);
        if (wb != mwriter->buf.len)
        {
            if (wb < 0)
                pg_fatal("could not write \"%s\": %m", mwriter->pathname);
            else
                pg_fatal("could not write file \"%s\": wrote only %d of %d bytes",
                         mwriter->pathname, (int) wb, mwriter->buf.len);
        }
 
        if (mwriter->still_checksumming &&
            pg_checksum_update(&mwriter->manifest_ctx,
                               (uint8 *) mwriter->buf.data,
                               mwriter->buf.len) < 0)
            pg_fatal("could not update checksum of file \"%s\"",
                     mwriter->pathname);
        resetStringInfo(&mwriter->buf);
    }
}

References manifest_writer::buf, StringInfoData::data, manifest_writer::fd, StringInfoData::len, manifest_writer::manifest_ctx, manifest_writer::pathname, PG_BINARY, pg_checksum_update(), pg_fatal, pg_file_create_mode, resetStringInfo(), manifest_writer::still_checksumming, and write.

Referenced by add_file_to_manifest(), and finalize_manifest().

hex_encode()

static size_t hex_encode ( const uint8 *  src, size_t  len, char *  dst  )

static

Definition at line 280 of file write_manifest.c.

{
    const uint8 *end = src + len;
 
    while (src < end)
    {
        unsigned    n1 = (*src >> 4) & 0xF;
        unsigned    n2 = *src & 0xF;
 
        *dst++ = n1 < 10 ? '0' + n1 : 'a' + n1 - 10;
        *dst++ = n2 < 10 ? '0' + n2 : 'a' + n2 - 10;
        ++src;
    }
 
    return len * 2;
}

References len.

Referenced by add_file_to_manifest(), and finalize_manifest().