TLA  Line data    Source code

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