Branch data     Line data    Source code

       1                 :             : /*-------------------------------------------------------------------------
       2                 :             :  *
       3                 :             :  * basebackup_sink.c
       4                 :             :  *        Default implementations for bbsink (basebackup sink) callbacks.
       5                 :             :  *
       6                 :             :  * Portions Copyright (c) 2010-2026, 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                 :           0 : bbsink_forward_begin_backup(bbsink *sink)
      25                 :             : {
      26         [ #  # ]:           0 :         Assert(sink->bbs_next != NULL);
      27         [ #  # ]:           0 :         Assert(sink->bbs_state != NULL);
      28                 :           0 :         bbsink_begin_backup(sink->bbs_next, sink->bbs_state,
      29                 :           0 :                                                 sink->bbs_buffer_length);
      30                 :           0 :         sink->bbs_buffer = sink->bbs_next->bbs_buffer;
      31                 :           0 : }
      32                 :             : 
      33                 :             : /*
      34                 :             :  * Forward begin_archive callback.
      35                 :             :  */
      36                 :             : void
      37                 :           0 : bbsink_forward_begin_archive(bbsink *sink, const char *archive_name)
      38                 :             : {
      39         [ #  # ]:           0 :         Assert(sink->bbs_next != NULL);
      40                 :           0 :         bbsink_begin_archive(sink->bbs_next, archive_name);
      41                 :           0 : }
      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                 :           0 : bbsink_forward_archive_contents(bbsink *sink, size_t len)
      55                 :             : {
      56         [ #  # ]:           0 :         Assert(sink->bbs_next != NULL);
      57         [ #  # ]:           0 :         Assert(sink->bbs_buffer == sink->bbs_next->bbs_buffer);
      58         [ #  # ]:           0 :         Assert(sink->bbs_buffer_length == sink->bbs_next->bbs_buffer_length);
      59                 :           0 :         bbsink_archive_contents(sink->bbs_next, len);
      60                 :           0 : }
      61                 :             : 
      62                 :             : /*
      63                 :             :  * Forward end_archive callback.
      64                 :             :  */
      65                 :             : void
      66                 :           0 : bbsink_forward_end_archive(bbsink *sink)
      67                 :             : {
      68         [ #  # ]:           0 :         Assert(sink->bbs_next != NULL);
      69                 :           0 :         bbsink_end_archive(sink->bbs_next);
      70                 :           0 : }
      71                 :             : 
      72                 :             : /*
      73                 :             :  * Forward begin_manifest callback.
      74                 :             :  */
      75                 :             : void
      76                 :           0 : bbsink_forward_begin_manifest(bbsink *sink)
      77                 :             : {
      78         [ #  # ]:           0 :         Assert(sink->bbs_next != NULL);
      79                 :           0 :         bbsink_begin_manifest(sink->bbs_next);
      80                 :           0 : }
      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                 :           0 : bbsink_forward_manifest_contents(bbsink *sink, size_t len)
      90                 :             : {
      91         [ #  # ]:           0 :         Assert(sink->bbs_next != NULL);
      92         [ #  # ]:           0 :         Assert(sink->bbs_buffer == sink->bbs_next->bbs_buffer);
      93         [ #  # ]:           0 :         Assert(sink->bbs_buffer_length == sink->bbs_next->bbs_buffer_length);
      94                 :           0 :         bbsink_manifest_contents(sink->bbs_next, len);
      95                 :           0 : }
      96                 :             : 
      97                 :             : /*
      98                 :             :  * Forward end_manifest callback.
      99                 :             :  */
     100                 :             : void
     101                 :           0 : bbsink_forward_end_manifest(bbsink *sink)
     102                 :             : {
     103         [ #  # ]:           0 :         Assert(sink->bbs_next != NULL);
     104                 :           0 :         bbsink_end_manifest(sink->bbs_next);
     105                 :           0 : }
     106                 :             : 
     107                 :             : /*
     108                 :             :  * Forward end_backup callback.
     109                 :             :  */
     110                 :             : void
     111                 :           0 : bbsink_forward_end_backup(bbsink *sink, XLogRecPtr endptr, TimeLineID endtli)
     112                 :             : {
     113         [ #  # ]:           0 :         Assert(sink->bbs_next != NULL);
     114                 :           0 :         bbsink_end_backup(sink->bbs_next, endptr, endtli);
     115                 :           0 : }
     116                 :             : 
     117                 :             : /*
     118                 :             :  * Forward cleanup callback.
     119                 :             :  */
     120                 :             : void
     121                 :           0 : bbsink_forward_cleanup(bbsink *sink)
     122                 :             : {
     123         [ #  # ]:           0 :         Assert(sink->bbs_next != NULL);
     124                 :           0 :         bbsink_cleanup(sink->bbs_next);
     125                 :           0 : }