src/backend/backup/basebackup_target.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * basebackup_target.c
   4  *        Base backups can be "targeted", which means that they can be sent
   5  *        somewhere other than to the client which requested the backup.
   6  *        Furthermore, new targets can be defined by extensions. This file
   7  *        contains code to support that functionality.
   8  *
   9  * Portions Copyright (c) 2010-2024, PostgreSQL Global Development Group
  10  *
  11  * IDENTIFICATION
  12  *        src/backend/backup/basebackup_target.c
  13  *
  14  *-------------------------------------------------------------------------
  15  */
  16 #include "postgres.h"
  17
  18 #include "backup/basebackup_target.h"
  19 #include "utils/memutils.h"
  20
  21 typedef struct BaseBackupTargetType
  22 {
  23         char       *name;
  24         void       *(*check_detail) (char *, char *);
  25         bbsink     *(*get_sink) (bbsink *, void *);
  26 } BaseBackupTargetType;
  27
  28 struct BaseBackupTargetHandle
  29 {
  30         BaseBackupTargetType *type;
  31         void       *detail_arg;
  32 };
  33
  34 static void initialize_target_list(void);
  35 static bbsink *blackhole_get_sink(bbsink *next_sink, void *detail_arg);
  36 static bbsink *server_get_sink(bbsink *next_sink, void *detail_arg);
  37 static void *reject_target_detail(char *target, char *target_detail);
  38 static void *server_check_detail(char *target, char *target_detail);
  39
  40 static BaseBackupTargetType builtin_backup_targets[] =
  41 {
  42         {
  43                 "blackhole", reject_target_detail, blackhole_get_sink
  44         },
  45         {
  46                 "server", server_check_detail, server_get_sink
  47         },
  48         {
  49                 NULL
  50         }
  51 };
  52
  53 static List *BaseBackupTargetTypeList = NIL;
  54
  55 /*
  56  * Add a new base backup target type.
  57  *
  58  * This is intended for use by server extensions.
  59  */
  60 void
  61 BaseBackupAddTarget(char *name,
  62                                         void *(*check_detail) (char *, char *),
  63                                         bbsink *(*get_sink) (bbsink *, void *))
  64 {
  65         BaseBackupTargetType *newtype;
  66         MemoryContext oldcontext;
  67         ListCell   *lc;
  68
  69         /* If the target list is not yet initialized, do that first. */
  70         if (BaseBackupTargetTypeList == NIL)
  71                 initialize_target_list();
  72
  73         /* Search the target type list for an existing entry with this name. */
  74         foreach(lc, BaseBackupTargetTypeList)
  75         {
  76                 BaseBackupTargetType *ttype = lfirst(lc);
  77
  78                 if (strcmp(ttype->name, name) == 0)
  79                 {
  80                         /*
  81                          * We found one, so update it.
  82                          *
  83                          * It is probably not a great idea to call BaseBackupAddTarget for
  84                          * the same name multiple times, but if it happens, this seems
  85                          * like the sanest behavior.
  86                          */
  87                         ttype->check_detail = check_detail;
  88                         ttype->get_sink = get_sink;
  89                         return;
  90                 }
  91         }
  92
  93         /*
  94          * We use TopMemoryContext for allocations here to make sure that the data
  95          * we need doesn't vanish under us; that's also why we copy the target
  96          * name into a newly-allocated chunk of memory.
  97          */
  98         oldcontext = MemoryContextSwitchTo(TopMemoryContext);
  99         newtype = palloc(sizeof(BaseBackupTargetType));
 100         newtype->name = pstrdup(name);
 101         newtype->check_detail = check_detail;
 102         newtype->get_sink = get_sink;
 103         BaseBackupTargetTypeList = lappend(BaseBackupTargetTypeList, newtype);
 104         MemoryContextSwitchTo(oldcontext);
 105 }
 106
 107 /*
 108  * Look up a base backup target and validate the target_detail.
 109  *
 110  * Extensions that define new backup targets will probably define a new
 111  * type of bbsink to match. Validation of the target_detail can be performed
 112  * either in the check_detail routine called here, or in the bbsink
 113  * constructor, which will be called from BaseBackupGetSink. It's mostly
 114  * a matter of taste, but the check_detail function runs somewhat earlier.
 115  */
 116 BaseBackupTargetHandle *
 117 BaseBackupGetTargetHandle(char *target, char *target_detail)
 118 {
 119         ListCell   *lc;
 120
 121         /* If the target list is not yet initialized, do that first. */
 122         if (BaseBackupTargetTypeList == NIL)
 123                 initialize_target_list();
 124
 125         /* Search the target type list for a match. */
 126         foreach(lc, BaseBackupTargetTypeList)
 127         {
 128                 BaseBackupTargetType *ttype = lfirst(lc);
 129
 130                 if (strcmp(ttype->name, target) == 0)
 131                 {
 132                         BaseBackupTargetHandle *handle;
 133
 134                         /* Found the target. */
 135                         handle = palloc(sizeof(BaseBackupTargetHandle));
 136                         handle->type = ttype;
 137                         handle->detail_arg = ttype->check_detail(target, target_detail);
 138
 139                         return handle;
 140                 }
 141         }
 142
 143         /* Did not find the target. */
 144         ereport(ERROR,
 145                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 146                          errmsg("unrecognized target: \"%s\"", target)));
 147
 148         /* keep compiler quiet */
 149         return NULL;
 150 }
 151
 152 /*
 153  * Construct a bbsink that will implement the backup target.
 154  *
 155  * The get_sink function does all the real work, so all we have to do here
 156  * is call it with the correct arguments. Whatever the check_detail function
 157  * returned is here passed through to the get_sink function. This lets those
 158  * two functions communicate with each other, if they wish. If not, the
 159  * check_detail function can simply return the target_detail and let the
 160  * get_sink function take it from there.
 161  */
 162 bbsink *
 163 BaseBackupGetSink(BaseBackupTargetHandle *handle, bbsink *next_sink)
 164 {
 165         return handle->type->get_sink(next_sink, handle->detail_arg);
 166 }
 167
 168 /*
 169  * Load predefined target types into BaseBackupTargetTypeList.
 170  */
 171 static void
 172 initialize_target_list(void)
 173 {
 174         BaseBackupTargetType *ttype = builtin_backup_targets;
 175         MemoryContext oldcontext;
 176
 177         oldcontext = MemoryContextSwitchTo(TopMemoryContext);
 178         while (ttype->name != NULL)
 179         {
 180                 BaseBackupTargetTypeList = lappend(BaseBackupTargetTypeList, ttype);
 181                 ++ttype;
 182         }
 183         MemoryContextSwitchTo(oldcontext);
 184 }
 185
 186 /*
 187  * Normally, a get_sink function should construct and return a new bbsink that
 188  * implements the backup target, but the 'blackhole' target just throws the
 189  * data away. We could implement that by adding a bbsink that does nothing
 190  * but forward, but it's even cheaper to implement that by not adding a bbsink
 191  * at all.
 192  */
 193 static bbsink *
 194 blackhole_get_sink(bbsink *next_sink, void *detail_arg)
 195 {
 196         return next_sink;
 197 }
 198
 199 /*
 200  * Create a bbsink implementing a server-side backup.
 201  */
 202 static bbsink *
 203 server_get_sink(bbsink *next_sink, void *detail_arg)
 204 {
 205         return bbsink_server_new(next_sink, detail_arg);
 206 }
 207
 208 /*
 209  * Implement target-detail checking for a target that does not accept a
 210  * detail.
 211  */
 212 static void *
 213 reject_target_detail(char *target, char *target_detail)
 214 {
 215         if (target_detail != NULL)
 216                 ereport(ERROR,
 217                                 (errcode(ERRCODE_SYNTAX_ERROR),
 218                                  errmsg("target \"%s\" does not accept a target detail",
 219                                                 target)));
 220
 221         return NULL;
 222 }
 223
 224 /*
 225  * Implement target-detail checking for a server-side backup.
 226  *
 227  * target_detail should be the name of the directory to which the backup
 228  * should be written, but we don't check that here. Rather, that check,
 229  * as well as the necessary permissions checking, happens in bbsink_server_new.
 230  */
 231 static void *
 232 server_check_detail(char *target, char *target_detail)
 233 {
 234         if (target_detail == NULL)
 235                 ereport(ERROR,
 236                                 (errcode(ERRCODE_SYNTAX_ERROR),
 237                                  errmsg("target \"%s\" requires a target detail",
 238                                                 target)));
 239
 240         return target_detail;
 241 }