/*-------------------------------------------------------------------------

 *

 * basebackup_server.c

 *    store basebackup archives on the server

 *

 * IDENTIFICATION

 *    src/backend/backup/basebackup_server.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "access/xact.h"

#include "backup/basebackup_sink.h"

#include "catalog/pg_authid.h"

#include "miscadmin.h"

#include "storage/fd.h"

#include "utils/acl.h"

#include "utils/wait_event.h"

typedef struct bbsink_server

{

  /* Common information for all types of sink. */

  bbsink    base;

  /* Directory in which backup is to be stored. */

  char     *pathname;

  /* Currently open file (or 0 if nothing open). */

  File    file;

  /* Current file position. */

  off_t   filepos;

} bbsink_server;

static void bbsink_server_begin_archive(bbsink *sink,

                    const char *archive_name);

static void bbsink_server_archive_contents(bbsink *sink, size_t len);

static void bbsink_server_end_archive(bbsink *sink);

static void bbsink_server_begin_manifest(bbsink *sink);

static void bbsink_server_manifest_contents(bbsink *sink, size_t len);

static void bbsink_server_end_manifest(bbsink *sink);

static const bbsink_ops bbsink_server_ops = {

  .begin_backup = bbsink_forward_begin_backup,

  .begin_archive = bbsink_server_begin_archive,

  .archive_contents = bbsink_server_archive_contents,

  .end_archive = bbsink_server_end_archive,

  .begin_manifest = bbsink_server_begin_manifest,

  .manifest_contents = bbsink_server_manifest_contents,

  .end_manifest = bbsink_server_end_manifest,

  .end_backup = bbsink_forward_end_backup,

  .cleanup = bbsink_forward_cleanup

};

/*

 * Create a new 'server' bbsink.

 */

bbsink *

bbsink_server_new(bbsink *next, char *pathname)

{

  bbsink_server *sink = palloc0(sizeof(bbsink_server));

  *((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_server_ops;

  sink->pathname = pathname;

  sink->base.bbs_next = next;

  /* Replication permission is not sufficient in this case. */

  StartTransactionCommand();

  if (!has_privs_of_role(GetUserId(), ROLE_PG_WRITE_SERVER_FILES))

    ereport(ERROR,

        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),

         errmsg("permission denied to create backup stored on server"),

         errdetail("Only roles with privileges of the \"%s\" role may create a backup stored on the server.",

               "pg_write_server_files")));

  CommitTransactionCommand();

  /*

   * It's not a good idea to store your backups in the same directory that

   * you're backing up. If we allowed a relative path here, that could

   * easily happen accidentally, so we don't. The user could still

   * accomplish the same thing by including the absolute path to $PGDATA in

   * the pathname, but that's likely an intentional bad decision rather than

   * an accident.

   */

  if (!is_absolute_path(pathname))

    ereport(ERROR,

        (errcode(ERRCODE_INVALID_NAME),

         errmsg("relative path not allowed for backup stored on server")));

  switch (pg_check_dir(pathname))

  {

    case 0:

      /*

       * Does not exist, so create it using the same permissions we'd

       * use for a new subdirectory of the data directory itself.

       */

      if (MakePGDirectory(pathname) < 0)

        ereport(ERROR,

            (errcode_for_file_access(),

             errmsg("could not create directory \"%s\": %m", pathname)));

      break;

    case 1:

      /* Exists, empty. */

      break;

    case 2:

    case 3:

    case 4:

      /* Exists, not empty. */

      ereport(ERROR,

          (errcode(ERRCODE_DUPLICATE_FILE),

           errmsg("directory \"%s\" exists but is not empty",

              pathname)));

      break;

    default:

      /* Access problem. */

      ereport(ERROR,

          (errcode_for_file_access(),

           errmsg("could not access directory \"%s\": %m",

              pathname)));

  }

  return &sink->base;

}

/*

 * Open the correct output file for this archive.

 */

static void

bbsink_server_begin_archive(bbsink *sink, const char *archive_name)

{

  bbsink_server *mysink = (bbsink_server *) sink;

  char     *filename;

  Assert(mysink->file == 0);

  Assert(mysink->filepos == 0);

  filename = psprintf("%s/%s", mysink->pathname, archive_name);

  mysink->file = PathNameOpenFile(filename,

                  O_CREAT | O_EXCL | O_WRONLY | PG_BINARY);

  if (mysink->file <= 0)

    ereport(ERROR,

        (errcode_for_file_access(),

         errmsg("could not create file \"%s\": %m", filename)));

  pfree(filename);

  bbsink_forward_begin_archive(sink, archive_name);

}

/*

 * Write the data to the output file.

 */

static void

bbsink_server_archive_contents(bbsink *sink, size_t len)

{

  bbsink_server *mysink = (bbsink_server *) sink;

  int     nbytes;

  nbytes = FileWrite(mysink->file, mysink->base.bbs_buffer, len,

             mysink->filepos, WAIT_EVENT_BASEBACKUP_WRITE);

  if (nbytes != len)

  {

    if (nbytes < 0)

      ereport(ERROR,

          (errcode_for_file_access(),

           errmsg("could not write file \"%s\": %m",

              FilePathName(mysink->file)),

           errhint("Check free disk space.")));

    /* short write: complain appropriately */

    ereport(ERROR,

        (errcode(ERRCODE_DISK_FULL),

         errmsg("could not write file \"%s\": wrote only %d of %d bytes at offset %u",

            FilePathName(mysink->file),

            nbytes, (int) len, (unsigned) mysink->filepos),

         errhint("Check free disk space.")));

  }

  mysink->filepos += nbytes;

  bbsink_forward_archive_contents(sink, len);

}

/*

 * fsync and close the current output file.

 */

static void

bbsink_server_end_archive(bbsink *sink)

{

  bbsink_server *mysink = (bbsink_server *) sink;

  /*

   * We intentionally don't use data_sync_elevel here, because the server

   * shouldn't PANIC just because we can't guarantee that the backup has

   * been written down to disk. Running recovery won't fix anything in this

   * case anyway.

   */

  if (FileSync(mysink->file, WAIT_EVENT_BASEBACKUP_SYNC) < 0)

    ereport(ERROR,

        (errcode_for_file_access(),

         errmsg("could not fsync file \"%s\": %m",

            FilePathName(mysink->file))));

  /* We're done with this file now. */

  FileClose(mysink->file);

  mysink->file = 0;

  mysink->filepos = 0;

  bbsink_forward_end_archive(sink);

}

/*

 * Open the output file to which we will write the manifest.

 *

 * Just like pg_basebackup, we write the manifest first under a temporary

 * name and then rename it into place after fsync. That way, if the manifest

 * is there and under the correct name, the user can be sure that the backup

 * completed.

 */

static void

bbsink_server_begin_manifest(bbsink *sink)

{

  bbsink_server *mysink = (bbsink_server *) sink;

  char     *tmp_filename;

  Assert(mysink->file == 0);

  tmp_filename = psprintf("%s/backup_manifest.tmp", mysink->pathname);

  mysink->file = PathNameOpenFile(tmp_filename,

                  O_CREAT | O_EXCL | O_WRONLY | PG_BINARY);

  if (mysink->file <= 0)

    ereport(ERROR,

        (errcode_for_file_access(),

         errmsg("could not create file \"%s\": %m", tmp_filename)));

  pfree(tmp_filename);

  bbsink_forward_begin_manifest(sink);

}

/*

 * Each chunk of manifest data is sent using a CopyData message.

 */

static void

bbsink_server_manifest_contents(bbsink *sink, size_t len)

{

  bbsink_server *mysink = (bbsink_server *) sink;

  int     nbytes;

  nbytes = FileWrite(mysink->file, mysink->base.bbs_buffer, len,

             mysink->filepos, WAIT_EVENT_BASEBACKUP_WRITE);

  if (nbytes != len)

  {

    if (nbytes < 0)

      ereport(ERROR,

          (errcode_for_file_access(),

           errmsg("could not write file \"%s\": %m",

              FilePathName(mysink->file)),

           errhint("Check free disk space.")));

    /* short write: complain appropriately */

    ereport(ERROR,

        (errcode(ERRCODE_DISK_FULL),

         errmsg("could not write file \"%s\": wrote only %d of %d bytes at offset %u",

            FilePathName(mysink->file),

            nbytes, (int) len, (unsigned) mysink->filepos),

         errhint("Check free disk space.")));

  }

  mysink->filepos += nbytes;

  bbsink_forward_manifest_contents(sink, len);

}

/*

 * fsync the backup manifest, close the file, and then rename it into place.

 */

static void

bbsink_server_end_manifest(bbsink *sink)

{

  bbsink_server *mysink = (bbsink_server *) sink;

  char     *tmp_filename;

  char     *filename;

  /* We're done with this file now. */

  FileClose(mysink->file);

  mysink->file = 0;

  /*

   * Rename it into place. This also fsyncs the temporary file, so we don't

   * need to do that here. We don't use data_sync_elevel here for the same

   * reasons as in bbsink_server_end_archive.

   */

  tmp_filename = psprintf("%s/backup_manifest.tmp", mysink->pathname);

  filename = psprintf("%s/backup_manifest", mysink->pathname);

  durable_rename(tmp_filename, filename, ERROR);

  pfree(filename);

  pfree(tmp_filename);

  bbsink_forward_end_manifest(sink);

}