basebackup_target.c File Reference

#include "postgres.h"
#include "backup/basebackup_target.h"
#include "utils/memutils.h"

Include dependency graph for basebackup_target.c:

Go to the source code of this file.

Data Structures
struct	BaseBackupTargetType
struct	BaseBackupTargetHandle

Typedefs
typedef struct BaseBackupTargetType	BaseBackupTargetType

Functions
static void	initialize_target_list (void)
static bbsink *	blackhole_get_sink (bbsink *next_sink, void *detail_arg)
static bbsink *	server_get_sink (bbsink *next_sink, void *detail_arg)
static void *	reject_target_detail (char *target, char *target_detail)
static void *	server_check_detail (char *target, char *target_detail)
void	BaseBackupAddTarget (char *name, void *(*check_detail)(char *, char *), bbsink *(*get_sink)(bbsink *, void *))
BaseBackupTargetHandle *	BaseBackupGetTargetHandle (char *target, char *target_detail)
bbsink *	BaseBackupGetSink (BaseBackupTargetHandle *handle, bbsink *next_sink)

Variables
static BaseBackupTargetType	builtin_backup_targets []
static List *	BaseBackupTargetTypeList = NIL

Typedef Documentation

BaseBackupTargetType

typedef struct BaseBackupTargetType BaseBackupTargetType

Function Documentation

BaseBackupAddTarget()

void BaseBackupAddTarget	(	char *	name,
		void *(*)(char *, char *)	check_detail,
		bbsink *(*)(bbsink *, void *)	get_sink
	)

Definition at line 61 of file basebackup_target.c.

{
    BaseBackupTargetType *newtype;
    MemoryContext oldcontext;
    ListCell   *lc;
 
    /* If the target list is not yet initialized, do that first. */
    if (BaseBackupTargetTypeList == NIL)
        initialize_target_list();
 
    /* Search the target type list for an existing entry with this name. */
    foreach(lc, BaseBackupTargetTypeList)
    {
        BaseBackupTargetType *ttype = lfirst(lc);
 
        if (strcmp(ttype->name, name) == 0)
        {
            /*
             * We found one, so update it.
             *
             * It is probably not a great idea to call BaseBackupAddTarget for
             * the same name multiple times, but if it happens, this seems
             * like the sanest behavior.
             */
            ttype->check_detail = check_detail;
            ttype->get_sink = get_sink;
            return;
        }
    }
 
    /*
     * We use TopMemoryContext for allocations here to make sure that the data
     * we need doesn't vanish under us; that's also why we copy the target
     * name into a newly-allocated chunk of memory.
     */
    oldcontext = MemoryContextSwitchTo(TopMemoryContext);
    newtype = palloc(sizeof(BaseBackupTargetType));
    newtype->name = pstrdup(name);
    newtype->check_detail = check_detail;
    newtype->get_sink = get_sink;
    BaseBackupTargetTypeList = lappend(BaseBackupTargetTypeList, newtype);
    MemoryContextSwitchTo(oldcontext);
}

References BaseBackupTargetTypeList, BaseBackupTargetType::check_detail, BaseBackupTargetType::get_sink, initialize_target_list(), lappend(), lfirst, MemoryContextSwitchTo(), BaseBackupTargetType::name, name, NIL, palloc(), pstrdup(), and TopMemoryContext.

Referenced by _PG_init().

BaseBackupGetSink()

bbsink * BaseBackupGetSink	(	BaseBackupTargetHandle *	handle,
		bbsink *	next_sink
	)

Definition at line 163 of file basebackup_target.c.

{
    return handle->type->get_sink(next_sink, handle->detail_arg);
}

References BaseBackupTargetHandle::detail_arg, BaseBackupTargetType::get_sink, and BaseBackupTargetHandle::type.

Referenced by SendBaseBackup().

BaseBackupGetTargetHandle()

BaseBackupTargetHandle * BaseBackupGetTargetHandle	(	char *	target,
		char *	target_detail
	)

Definition at line 117 of file basebackup_target.c.

{
    ListCell   *lc;
 
    /* If the target list is not yet initialized, do that first. */
    if (BaseBackupTargetTypeList == NIL)
        initialize_target_list();
 
    /* Search the target type list for a match. */
    foreach(lc, BaseBackupTargetTypeList)
    {
        BaseBackupTargetType *ttype = lfirst(lc);
 
        if (strcmp(ttype->name, target) == 0)
        {
            BaseBackupTargetHandle *handle;
 
            /* Found the target. */
            handle = palloc(sizeof(BaseBackupTargetHandle));
            handle->type = ttype;
            handle->detail_arg = ttype->check_detail(target, target_detail);
 
            return handle;
        }
    }
 
    /* Did not find the target. */
    ereport(ERROR,
            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             errmsg("unrecognized target: \"%s\"", target)));
 
    /* keep compiler quiet */
    return NULL;
}

References BaseBackupTargetTypeList, BaseBackupTargetType::check_detail, BaseBackupTargetHandle::detail_arg, ereport, errcode(), errmsg(), ERROR, initialize_target_list(), lfirst, BaseBackupTargetType::name, NIL, palloc(), and BaseBackupTargetHandle::type.

Referenced by parse_basebackup_options().

blackhole_get_sink()

static bbsink * blackhole_get_sink ( bbsink *  next_sink, void *  detail_arg  )

static

Definition at line 194 of file basebackup_target.c.

{
    return next_sink;
}

initialize_target_list()

static void initialize_target_list ( void  )

static

Definition at line 172 of file basebackup_target.c.

{
    BaseBackupTargetType *ttype = builtin_backup_targets;
    MemoryContext oldcontext;
 
    oldcontext = MemoryContextSwitchTo(TopMemoryContext);
    while (ttype->name != NULL)
    {
        BaseBackupTargetTypeList = lappend(BaseBackupTargetTypeList, ttype);
        ++ttype;
    }
    MemoryContextSwitchTo(oldcontext);
}

References BaseBackupTargetTypeList, builtin_backup_targets, lappend(), MemoryContextSwitchTo(), BaseBackupTargetType::name, and TopMemoryContext.

Referenced by BaseBackupAddTarget(), and BaseBackupGetTargetHandle().

reject_target_detail()

static void * reject_target_detail ( char *  target, char *  target_detail  )

static

Definition at line 213 of file basebackup_target.c.

{
    if (target_detail != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("target \"%s\" does not accept a target detail",
                        target)));
 
    return NULL;
}

References ereport, errcode(), errmsg(), and ERROR.

server_check_detail()

static void * server_check_detail ( char *  target, char *  target_detail  )

static

Definition at line 232 of file basebackup_target.c.

{
    if (target_detail == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("target \"%s\" requires a target detail",
                        target)));
 
    return target_detail;
}

References ereport, errcode(), errmsg(), and ERROR.

server_get_sink()

static bbsink * server_get_sink ( bbsink *  next_sink, void *  detail_arg  )

static

Definition at line 203 of file basebackup_target.c.

{
    return bbsink_server_new(next_sink, detail_arg);
}

References bbsink_server_new().

Variable Documentation

BaseBackupTargetTypeList

List* BaseBackupTargetTypeList = NIL

static

Definition at line 53 of file basebackup_target.c.

Referenced by BaseBackupAddTarget(), BaseBackupGetTargetHandle(), and initialize_target_list().

builtin_backup_targets

BaseBackupTargetType builtin_backup_targets[]

static

Initial value:

=
{
    {
        "blackhole", reject_target_detail, blackhole_get_sink
    },
    {
        "server", server_check_detail, server_get_sink
    },
    {
        NULL
    }
}

Definition at line 40 of file basebackup_target.c.

Referenced by initialize_target_list().