Line data    Source code

       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * basebackup_sink.c
       4             :  *    Default implementations for bbsink (basebackup sink) callbacks.
       5             :  *
       6             :  * Portions Copyright (c) 2010-2024, PostgreSQL Global Development Group
       7             :  *
       8             :  * src/backend/backup/basebackup_sink.c
       9             :  *
      10             :  *-------------------------------------------------------------------------
      11             :  */
      12             : 
      13             : #include "postgres.h"
      14             : 
      15             : #include "backup/basebackup_sink.h"
      16             : 
      17             : /*
      18             :  * Forward begin_backup callback.
      19             :  *
      20             :  * Only use this implementation if you want the bbsink you're implementing to
      21             :  * share a buffer with the successor bbsink.
      22             :  */
      23             : void
      24         296 : bbsink_forward_begin_backup(bbsink *sink)
      25             : {
      26             :     Assert(sink->bbs_next != NULL);
      27             :     Assert(sink->bbs_state != NULL);
      28         296 :     bbsink_begin_backup(sink->bbs_next, sink->bbs_state,
      29         296 :                         sink->bbs_buffer_length);
      30         296 :     sink->bbs_buffer = sink->bbs_next->bbs_buffer;
      31         296 : }
      32             : 
      33             : /*
      34             :  * Forward begin_archive callback.
      35             :  */
      36             : void
      37         362 : bbsink_forward_begin_archive(bbsink *sink, const char *archive_name)
      38             : {
      39             :     Assert(sink->bbs_next != NULL);
      40         362 :     bbsink_begin_archive(sink->bbs_next, archive_name);
      41         362 : }
      42             : 
      43             : /*
      44             :  * Forward archive_contents callback.
      45             :  *
      46             :  * Code that wants to use this should initialize its own bbs_buffer and
      47             :  * bbs_buffer_length fields to the values from the successor sink. In cases
      48             :  * where the buffer isn't shared, the data needs to be copied before forwarding
      49             :  * the callback. We don't do try to do that here, because there's really no
      50             :  * reason to have separately allocated buffers containing the same identical
      51             :  * data.
      52             :  */
      53             : void
      54      641814 : bbsink_forward_archive_contents(bbsink *sink, size_t len)
      55             : {
      56             :     Assert(sink->bbs_next != NULL);
      57             :     Assert(sink->bbs_buffer == sink->bbs_next->bbs_buffer);
      58             :     Assert(sink->bbs_buffer_length == sink->bbs_next->bbs_buffer_length);
      59      641814 :     bbsink_archive_contents(sink->bbs_next, len);
      60      641812 : }
      61             : 
      62             : /*
      63             :  * Forward end_archive callback.
      64             :  */
      65             : void
      66         350 : bbsink_forward_end_archive(bbsink *sink)
      67             : {
      68             :     Assert(sink->bbs_next != NULL);
      69         350 :     bbsink_end_archive(sink->bbs_next);
      70         350 : }
      71             : 
      72             : /*
      73             :  * Forward begin_manifest callback.
      74             :  */
      75             : void
      76         282 : bbsink_forward_begin_manifest(bbsink *sink)
      77             : {
      78             :     Assert(sink->bbs_next != NULL);
      79         282 :     bbsink_begin_manifest(sink->bbs_next);
      80         282 : }
      81             : 
      82             : /*
      83             :  * Forward manifest_contents callback.
      84             :  *
      85             :  * As with the archive_contents callback, it's expected that the buffer is
      86             :  * shared.
      87             :  */
      88             : void
      89        1422 : bbsink_forward_manifest_contents(bbsink *sink, size_t len)
      90             : {
      91             :     Assert(sink->bbs_next != NULL);
      92             :     Assert(sink->bbs_buffer == sink->bbs_next->bbs_buffer);
      93             :     Assert(sink->bbs_buffer_length == sink->bbs_next->bbs_buffer_length);
      94        1422 :     bbsink_manifest_contents(sink->bbs_next, len);
      95        1422 : }
      96             : 
      97             : /*
      98             :  * Forward end_manifest callback.
      99             :  */
     100             : void
     101         282 : bbsink_forward_end_manifest(bbsink *sink)
     102             : {
     103             :     Assert(sink->bbs_next != NULL);
     104         282 :     bbsink_end_manifest(sink->bbs_next);
     105         282 : }
     106             : 
     107             : /*
     108             :  * Forward end_backup callback.
     109             :  */
     110             : void
     111         284 : bbsink_forward_end_backup(bbsink *sink, XLogRecPtr endptr, TimeLineID endtli)
     112             : {
     113             :     Assert(sink->bbs_next != NULL);
     114         284 :     bbsink_end_backup(sink->bbs_next, endptr, endtli);
     115         284 : }
     116             : 
     117             : /*
     118             :  * Forward cleanup callback.
     119             :  */
     120             : void
     121         288 : bbsink_forward_cleanup(bbsink *sink)
     122             : {
     123             :     Assert(sink->bbs_next != NULL);
     124         288 :     bbsink_cleanup(sink->bbs_next);
     125         288 : }