parse_manifest.h File Reference

#include "access/xlogdefs.h"
#include "common/checksum_helper.h"
#include "mb/pg_wchar.h"

Include dependency graph for parse_manifest.h:

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

Go to the source code of this file.

Data Structures
struct	JsonManifestParseContext

Typedefs
typedef struct JsonManifestParseContext	JsonManifestParseContext
typedef struct JsonManifestParseIncrementalState	JsonManifestParseIncrementalState
typedef void(*	json_manifest_version_callback) (JsonManifestParseContext *, int manifest_version)
typedef void(*	json_manifest_system_identifier_callback) (JsonManifestParseContext *, uint64 manifest_system_identifier)
typedef void(*	json_manifest_per_file_callback) (JsonManifestParseContext *, const char *pathname, uint64 size, pg_checksum_type checksum_type, int checksum_length, uint8 *checksum_payload)
typedef void(*	json_manifest_per_wal_range_callback) (JsonManifestParseContext *, TimeLineID tli, XLogRecPtr start_lsn, XLogRecPtr end_lsn)
typedef void(*	json_manifest_error_callback) (JsonManifestParseContext *, const char *fmt,...) pg_attribute_printf(2

Functions
void	json_parse_manifest (JsonManifestParseContext *context, const char *buffer, size_t size)
JsonManifestParseIncrementalState *	json_parse_manifest_incremental_init (JsonManifestParseContext *context)
void	json_parse_manifest_incremental_chunk (JsonManifestParseIncrementalState *incstate, const char *chunk, size_t size, bool is_last)
void	json_parse_manifest_incremental_shutdown (JsonManifestParseIncrementalState *incstate)

Typedef Documentation

json_manifest_error_callback

typedef void(* json_manifest_error_callback) (JsonManifestParseContext *, const char *fmt,...) pg_attribute_printf(2

Definition at line 36 of file parse_manifest.h.

json_manifest_per_file_callback

typedef void(* json_manifest_per_file_callback) (JsonManifestParseContext *, const char *pathname, uint64 size, pg_checksum_type checksum_type, int checksum_length, uint8 *checksum_payload)

Definition at line 29 of file parse_manifest.h.

json_manifest_per_wal_range_callback

typedef void(* json_manifest_per_wal_range_callback) (JsonManifestParseContext *, TimeLineID tli, XLogRecPtr start_lsn, XLogRecPtr end_lsn)

Definition at line 33 of file parse_manifest.h.

json_manifest_system_identifier_callback

typedef void(* json_manifest_system_identifier_callback) (JsonManifestParseContext *, uint64 manifest_system_identifier)

Definition at line 27 of file parse_manifest.h.

json_manifest_version_callback

typedef void(* json_manifest_version_callback) (JsonManifestParseContext *, int manifest_version)

Definition at line 25 of file parse_manifest.h.

JsonManifestParseContext

typedef struct JsonManifestParseContext JsonManifestParseContext

Definition at line 22 of file parse_manifest.h.

JsonManifestParseIncrementalState

typedef struct JsonManifestParseIncrementalState JsonManifestParseIncrementalState

Definition at line 23 of file parse_manifest.h.

Function Documentation

json_parse_manifest()

void json_parse_manifest ( JsonManifestParseContext *  context, const char *  buffer, size_t  size  )

extern

Definition at line 227 of file parse_manifest.c.

{
    JsonLexContext *lex;
    JsonParseErrorType json_error;
    JsonSemAction sem;
    JsonManifestParseState parse;
 
    /* Set up our private parsing context. */
    parse.context = context;
    parse.state = JM_EXPECT_TOPLEVEL_START;
    parse.saw_version_field = false;
 
    /* Create a JSON lexing context. */
    lex = makeJsonLexContextCstringLen(NULL, buffer, size, PG_UTF8, true);
 
    /* Set up semantic actions. */
    sem.semstate = &parse;
    sem.object_start = json_manifest_object_start;
    sem.object_end = json_manifest_object_end;
    sem.array_start = json_manifest_array_start;
    sem.array_end = json_manifest_array_end;
    sem.object_field_start = json_manifest_object_field_start;
    sem.object_field_end = NULL;
    sem.array_element_start = NULL;
    sem.array_element_end = NULL;
    sem.scalar = json_manifest_scalar;
 
    /* Run the actual JSON parser. */
    json_error = pg_parse_json(lex, &sem);
    if (json_error != JSON_SUCCESS)
        json_manifest_parse_failure(context, json_errdetail(json_error, lex));
    if (parse.state != JM_EXPECT_EOF)
        json_manifest_parse_failure(context, "manifest ended unexpectedly");
 
    /* Verify the manifest checksum. */
    verify_manifest_checksum(&parse, buffer, size, NULL);
 
    freeJsonLexContext(lex);
}

References JsonSemAction::array_element_end, JsonSemAction::array_element_start, JsonSemAction::array_end, JsonSemAction::array_start, fb(), freeJsonLexContext(), JM_EXPECT_EOF, JM_EXPECT_TOPLEVEL_START, json_errdetail(), json_manifest_array_end(), json_manifest_array_start(), json_manifest_object_end(), json_manifest_object_field_start(), json_manifest_object_start(), json_manifest_parse_failure(), json_manifest_scalar(), JSON_SUCCESS, makeJsonLexContextCstringLen(), JsonSemAction::object_end, JsonSemAction::object_field_end, JsonSemAction::object_field_start, JsonSemAction::object_start, parse(), pg_parse_json(), PG_UTF8, JsonSemAction::scalar, sem, JsonSemAction::semstate, and verify_manifest_checksum().

Referenced by load_backup_manifest(), and parse_manifest_file().

json_parse_manifest_incremental_chunk()

void json_parse_manifest_incremental_chunk ( JsonManifestParseIncrementalState *  incstate, const char *  chunk, size_t  size, bool  is_last  )

extern

Definition at line 185 of file parse_manifest.c.

{
    JsonParseErrorType res,
                expected;
    JsonManifestParseState *parse = incstate->sem.semstate;
    JsonManifestParseContext *context = parse->context;
 
    res = pg_parse_json_incremental(&(incstate->lex), &(incstate->sem),
                                    chunk, size, is_last);
 
    expected = is_last ? JSON_SUCCESS : JSON_INCOMPLETE;
 
    if (res != expected)
        json_manifest_parse_failure(context,
                                    json_errdetail(res, &(incstate->lex)));
 
    if (is_last && parse->state != JM_EXPECT_EOF)
        json_manifest_parse_failure(context, "manifest ended unexpectedly");
 
    if (!is_last)
    {
        if (pg_cryptohash_update(incstate->manifest_ctx,
                                 (const uint8 *) chunk, size) < 0)
            context->error_cb(context, "could not update checksum of manifest");
    }
    else
    {
        verify_manifest_checksum(parse, chunk, size, incstate->manifest_ctx);
    }
}

References JsonManifestParseContext::error_cb, fb(), JM_EXPECT_EOF, json_errdetail(), JSON_INCOMPLETE, json_manifest_parse_failure(), JSON_SUCCESS, parse(), pg_cryptohash_update(), pg_parse_json_incremental(), and verify_manifest_checksum().

Referenced by AppendIncrementalManifestData(), FinalizeIncrementalManifest(), load_backup_manifest(), and parse_manifest_file().

json_parse_manifest_incremental_init()

JsonManifestParseIncrementalState * json_parse_manifest_incremental_init ( JsonManifestParseContext *  context )

extern

Definition at line 129 of file parse_manifest.c.

{
    JsonManifestParseIncrementalState *incstate;
    JsonManifestParseState *parse;
    pg_cryptohash_ctx *manifest_ctx;
 
    incstate = palloc_object(JsonManifestParseIncrementalState);
    parse = palloc_object(JsonManifestParseState);
 
    parse->context = context;
    parse->state = JM_EXPECT_TOPLEVEL_START;
    parse->saw_version_field = false;
 
    makeJsonLexContextIncremental(&(incstate->lex), PG_UTF8, true);
 
    incstate->sem.semstate = parse;
    incstate->sem.object_start = json_manifest_object_start;
    incstate->sem.object_end = json_manifest_object_end;
    incstate->sem.array_start = json_manifest_array_start;
    incstate->sem.array_end = json_manifest_array_end;
    incstate->sem.object_field_start = json_manifest_object_field_start;
    incstate->sem.object_field_end = NULL;
    incstate->sem.array_element_start = NULL;
    incstate->sem.array_element_end = NULL;
    incstate->sem.scalar = json_manifest_scalar;
 
    manifest_ctx = pg_cryptohash_create(PG_SHA256);
    if (manifest_ctx == NULL)
        context->error_cb(context, "out of memory");
    if (pg_cryptohash_init(manifest_ctx) < 0)
        context->error_cb(context, "could not initialize checksum of manifest");
    incstate->manifest_ctx = manifest_ctx;
 
    return incstate;
}

References JsonManifestParseContext::error_cb, fb(), JM_EXPECT_TOPLEVEL_START, json_manifest_array_end(), json_manifest_array_start(), json_manifest_object_end(), json_manifest_object_field_start(), json_manifest_object_start(), json_manifest_scalar(), makeJsonLexContextIncremental(), palloc_object, parse(), pg_cryptohash_create(), pg_cryptohash_init(), PG_SHA256, and PG_UTF8.

Referenced by CreateIncrementalBackupInfo(), load_backup_manifest(), and parse_manifest_file().

json_parse_manifest_incremental_shutdown()

void json_parse_manifest_incremental_shutdown ( JsonManifestParseIncrementalState *  incstate )

extern

Definition at line 169 of file parse_manifest.c.

{
    pfree(incstate->sem.semstate);
    freeJsonLexContext(&(incstate->lex));
    /* incstate->manifest_ctx has already been freed */
    pfree(incstate);
}

References fb(), freeJsonLexContext(), and pfree().

Referenced by FinalizeIncrementalManifest(), load_backup_manifest(), and parse_manifest_file().