Up to [cvs.NetBSD.org] / pkgsrc / databases / py-barman
Request diff between arbitrary revisions
Keyword substitution: kv
Default branch: MAIN
py-barman: updated to 3.19.1 3.19.1 (2026-05-26) Bugfixes - Fix `cloud-wal-restore` failing to find compressed WAL files Fixed a bug where `barman-cloud-wal-restore` and `barman cloud-wal-restore` commands would fail to locate a compressed WAL file when a backup file with the same prefix existed in the cloud storage bucket. For example, when requesting WAL `00000001000000030000001A` and the bucket contained both `00000001000000030000001A.gz` and `00000001000000030000001A.00000028.backup.gz`, Barman would only locate the backup file and then write an error log like: ``` ERROR: WAL file 00000001000000030000001A for server pg does not exist ``` The issue is now fixed and WAL files are correctly identified even when backup files with the same prefix are present in the bucket.
py-barman: updated to 3.19.0 3.19.0 (2026-05-20) Notable changes - Add support for restoring backups from cloud storage Barman can now restore backups taken with `backup_method = local-to-cloud` or `backup_method = postgres` when stored in cloud object storage. The standard `barman restore` command can be used to restore such backups. For WAL restore, a new `barman cloud-wal-restore` command was introduced to fetch WAL files directly from cloud storage during recovery. This command can be used as the `restore_command` in PostgreSQL and supports parallel fetching for improved performance. Also, when a server has `wals_directory` configured to use cloud storage, `get-wal` is now always required for restore operations. If `--no-get-wal` is specified or `get-wal` is absent from `recovery_options`, Barman will automatically enable `get-wal` and issue a warning so the restore can proceed without interruption. This completes the cloud backup lifecycle, enabling seamless backup and recovery workflows entirely in the cloud. - Add new barman export-backup command for exporting backups to tarball Introduced a new `barman export-backup` command that exports a backup to a tarball format. The command takes a server name, backup ID, and destination directory as arguments, and creates a tarball containing the backup data. This provides an easy way to share or archive backups. - Add the `barman import-backup` command for importing backups from tarball Introduced a new `barman import-backup` command that imports a backup from a tarball format. The command takes a server name and tarball path as arguments, and provides a way to register previously exported backups back into a Barman catalog.
py-barman: updated to 3.17.0 3.17.0 (2026-01-07) Notable changes - Enable query, fetch, and selective operations on inactive/disabled servers Multiple Barman commands now work with inactive and disabled servers based on their safety profile: **Query commands**: - `list-backups`: view backups from inactive/disabled servers - `status`: check status of inactive/disabled servers - `show-backup`: display backup details from inactive/disabled servers - `list-files`: list files from backups on inactive/disabled servers - `verify-backup`: verify backups on inactive/disabled servers **Fetch commands**: - `restore`: restore backups from inactive servers - `get-wal`: retrieve WAL files from inactive servers **Modification commands**: - `delete`: delete backups from inactive servers - `config-switch`: switch configuration models for inactive/disabled servers This change improves operational flexibility by allowing users to query backup information and perform restore operations even when servers are manually disabled (inactive) or have configuration issues (disabled). The different behavior for disabled servers provides safety against operations on servers with potential configuration conflicts or path issues. References: BAR-976. - Deprecate custom compression for WAL files The `custom` compression option and its related configuration options (`custom_compression_filter`, `custom_decompression_filter`, and `custom_compression_magic`) are now deprecated and will be removed in a future release. Users currently using custom compression are advised to migrate to one of the built-in compression algorithms supported by Barman: `gzip`, `bzip2`, `lz4`, `xz`, `zstd`, or `pigz`. The custom compression feature was designed to provide flexibility for users with specific compression requirements, but maintaining compatibility with arbitrary external compression tools has proven to be complex and error-prone. The built-in compression options provide better performance, reliability, and maintainability. Existing configurations using custom compression will continue to work in the current release, but users should plan to migrate their configurations before the feature is removed.
py-barman: updated to 3.16.2
3.16.2 (2025-11-04)
Bugfixes
- Improve barman-cloud delete workaround to inspect error message content
Some S3-compatible storages return an "InvalidRequest" error instead of
"MissingContentMD5" during delete operations. Since we cannot rely on the error code
alone, this updates the logic to also inspect the error message text to detect
MissingContentMD5-like issues and apply the appropriate fallback.
References: BAR-947.
3.16.1 (2025-10-14)
Notable changes
- Automatic bucket creation added to barman-cloud-check-wal-archive
The `barman-cloud-check-wal-archive` command now verifies whether the target bucket
exists in the configured cloud storage (e.g., AWS S3) and automatically creates it
if it does not.
Previously, automatic bucket creation was handled by `barman-cloud-backup`. This
change restores compatibility with CloudNativePG (CNPG) automations that depend on
this behavior, which were affected after the release of Barman 3.16.0.
In collaboration with the CloudNativePG team, we have reintroduced this
functionality specifically in `barman-cloud-check-wal-archive` to ensure seamless
operation of CNPG workflows and internal tests — all while preserving the intended
behavior and simplicity for regular Barman users.
References: BAR-931.
3.16.0 (2025-10-02)
Notable changes
- The `restore_command` for local restores no longer includes `sudo`
When using `barman restore --get-wal` for a local restore (i.e. without
`--remote-ssh-command`), the generated `restore_command` no longer includes a
`sudo -u $USER` prefix. This simplifies the process for the common case where the
locally restored Postgres cluster is run by the `barman` user, whom already owns the
files by the end of the `barman restore` operation.
**Action Required:** If you intend to run the restored cluster as a different
user (e.g., `postgres`), you must now manually add the appropriate
`sudo -u postgres` prefix to the `restore_command` in the recovery configuration and
ensure file ownership is correct.
References: BAR-675.
- Deprecate `pygzip` and `pybzip2` compression options
The `pygzip` and `pybzip2` compression options are now deprecated and will be
removed in a future release. Users should migrate to the `gzip` and `bzip2` options,
which now use Python's internal libraries.
This change was made to improve performance and code consistency. Previously, the
`gzip` and `bzip2` options relied on external subprocesses, while their `py`
counterparts used native Python libraries. The core compression logic for `gzip` and
`bzip2` has been updated to also use Python's built-in libraries, making the
`pygzip` and `pybzip2` options redundant.
References: BAR-878.
- Add delta-restore flag and recovery option to barman restore
Introduces the --delta-restore flag for barman restore, enabling delta
restore mode. This mode restores a backup by reusing identical data already present
in the destination directory, which drastically reduces restore time and network
traffic.
This feature is also configurable per-server via 'recovery_options' as a new field
called delta-restore in the server configuration file.
References: BAR-788.
- S3 Object Deletion Fallback for Object Stores non-compliant with boto3 >=1.36
When using `delete_objects()` with some non-compliant S3-compatible object
stores, users could encounter a `MissingContentMD5` `ClientError` due to a breaking
change in boto3 1.36 that Botocore will no longer automatically compute and populate
the `Content-MD5` header.
To address this, Barman now implements a fallback mechanism:
- Bulk deletion via `delete_objects()` is still attempted first.
- If `delete_objects()` fails with `MissingContentMD5`, Barman automatically falls back
to deleting objects individually using `delete_object()`, which does not require a
`Content-MD5` header.
- Other errors continue to raise exceptions as before.
This change ensures Barman remains compatible with non-compliant object
stores without requiring changes on the user's side.
Users with older S3-compatible storage can continue performing backup cleanups
without failures, while newer object stores are unaffected.
References: BAR-909.
- Cloud connectivity checks are now only performed with the `-t`/`--test` flag.
Previously, Barman always tested cloud connectivity and bucket existence
for most of the commands, raising errors if connectivity failed or if the bucket
did not exist. Both checks are now executed only when the `-t`/`--test` flag is
specified. The only exception was `barman-cloud-check-wal-archive`, which still
checks connectivity and the existence of the bucket.
Additionally, buckets are no longer created automatically — Barman assumes the
target bucket already exists, making it the user's responsibility to provision
the bucket in advance.
References: BAR-895, BAR-908, BAR-918.
Minor changes
- Add `combine-mode` option to `barman restore` command
Added a `--combine-mode` option to the `barman restore` command, which can be used
to specify a copy mode for `pg_combinebackup` when combining incremental backups
during a restore. Available modes are `copy`, `link`, `clone`, and `copy-file-range`
which are equivalent to the `pg_combinebackup` options `--copy`, `--link`,
`--clone`, and `--copy-file-range`, respectively. An equivalent `combine_mode`
configuration option can be specified in the configuration file.
This feature allows for greater optimization of the restore process
based on the underlying filesystem capabilities.
References: BAR-870.
- Reorganize fields in barman diagnose JSON
In the barman diagnose JSON, some fields appeared under the server's "config"
section even though they were not actual configuration fields.
The fields "barman_lock_directory", "lock_directory_cleanup", and
"config_changes_queue" were relocated under the "global" key, since they represent
global configurations. The "name" field was removed since the server name is already
used as the key. Additionally, "msg_list" is now stored under the server's name key.
References: BAR-134.
- Add '-p JOBS' to barman-wal-restore command when `--get-wal` is `True`
Adds '-p JOBS' to barman-wal-restore command when `--get-wal` or `get_wal`
configuration option is ``True``, `JOBS` being the number of jobs chosen by the user
via `-p` flag or `parallel_jobs` configuration option.
References: BAR-857.
- The `barman show-backup`` command now displays the backup compression method
The output of the `barman show-backup` command has been enhanced to include a new
`Backup Compression` field. If a backup was taken with compression enabled, this
field will now display the compression algorithm that was used (e.g., `zstd`). This
makes it easier to quickly verify the compression status of a backup.
References: BAR-901.
Bugfixes
- Fix parallelism (--parallel option) in barman-wal-restore
There has been a regression in `barman-wal-restore` when introducing the
`--keep-compression` option in Barman 3.12.0, which made the `--parallel` option
not invoke processes as expected. This issue has now been fixed.
References: BAR-865.
- Fix `pg_combinebackup` not being found in `PATH` when `staging_location` is `remote`
When recovering an incremental backup to a remote server with `staging_location`
set to `remote`, Barman checks if `pg_combinebackup` is available in the remote `PATH`.
However, a previous issue was making it incorrectly check the local `PATH` as well,
leading to errors if `pg_combinebackup` was not installed locally.
The problem has been fixed by ensuring that the check is only performed on the
server where `pg_combinebackup` is actually executed.
References: BAR-903.
py-barman: updated to 3.15.0 3.15.0 Notable changes Allow incremental backups to be taken with compression and encryption Previously, Barman prevented incremental backups to be taken if compression was enabled or if the parent backup was already compressed. Since encryption in Barman requires compression, this also meant that incremental backups could not be taken with encryption. This limitation existed due to the complexity of restoring such backups, which involves multiple staging phases for decryption, decompression, and combination of backups. After a significant refactoring effort, Barman now fully supports taking incremental backups with both compression and/or encryption. This allows for more flexible backup strategies, enabling users to take advantage of all available features without restrictions. References: BAR-764, BAR-801, BAR-841. Deprecate local_staging_path and recovery_staging_path configuration options The local_staging_path and recovery_staging_path configuration options have been deprecated in favor of the new staging_path and staging_location options. The old options will continue to work for backwards compatibility, but users are encouraged to migrate to the new configuration options for better clarity and flexibility. References: BAR-571, BAR-801. Improve flexibility and consistency of staging area configuration Whenever restoring a compressed, encrypted or incremental backup, Barman needs a staging area to handle intermediate files, such as decompressed or decrypted files, or the combined incremental backup data. Previously, Barman used to have different configuration options for each scenario: For incremental backups, the staging area was specified via the local_staging_path in the Barman configuration, which could only be a path in the Barman host. For compressed backups, the staging area was specified via the recovery_staging_path, which could be a path in the Barman host (in case of local recovery) or a path in the target server (in case of remote recovery to a different server). For encrypted backups, the staging area was specified via the local_staging_path in the Barman configuration, which could only be a path in the Barman host. Note that, since encryption requires compression to be enabled, when restoring an encrypted backup, users needed to specify both recovery_staging_path and local_staging_path. Barman now provides a single, unified and more flexible staging area configuration: The new staging_path configuration option can be used to specify an absolute path for the staging area, where intermediate files will be stored. The default value is /tmp. The new staging_location configuration option can be used to specify whether the staging area is on the Barman host (local) or on the remote server (remote). The default value is local. This means that, besides having a unified configuration for the staging path, users are now also able to specify with more flexibility where the staging area should be located, either on the Barman host or on the remote Postgres server. Storage usage has also been optimized to reduce resource consumption whenever possible. This includes: Removing intermediate files as soon as they are no longer needed. Avoid using the staging area when not necessary, e.g. when restoring a compressed backup locally, no staging is needed and the backup is decompressed directly to its final destination. This change simplifies configuration and improves consistency and resource usage, making the recovery management more transparent and predictable for end users. References: BAR-764, BAR-765, BAR-801, BAR-841.
py-barman: updated to 3.14.0 3.14.0 (2025-05-15) Notable changes - Implementation of GPG encryption for tar backups and WAL files Implement GPG encryption of tar backups. Encryption starts at the end of the backup, encrypting the backup of PGDATA and tablespaces present in the backup directory. Encrypted backup files will have the `.gpg` extension added. Barman supports the decryption and restoration of GPG-encrypted backups using a passphrase obtained through the new `encryption_passphrase_command` configuration option. During the restore process, decrypted files are staged in the `local_staging_path` setting on the Barman host, ensuring a reliable and safe restore process. New configuration options required for encryption and decryption of backups and WAL files needed to be added. The new options are `encryption`, `encryption_key_id`, and `encryption_passphrase_command`. WAL files are all encrypted with GPG when `encryption = gpg`. This includes changing the way that xlogdb records are read and written (maintaining backwards compatibility), and a new logic to detect when files are encrypted and the encryption process itself. Decryption of GPG-encrypted WAL files during the restore process when using the get-wal and no-get-wal flags of the barman restore command. This extends the functionality added for decrypting backups via the `encryption_passphrase_command` configuration option. There's a new field in `show-backup` to expose if a backup was encrypted, and specifies the encryption method that was used, if any. The `barman check` command verifies if the user's encryption settings are correctly configured in the Barman server and functioning as expected. Minor changes - Allow compression level to be specified for WAL compression in Barman server Add a new `compression_level` parameter to the Barman configuration. This option accepts a valid integer value or one of the predefined options: `low`, `medium`, and `high`. Each option corresponds to a different level depending on the compression algorithm chosen. - Add client-side compression to `barman-wal-archive` Client-side compression options have been added to `barman-wal-archive`, supporting the same algorithms that are available on a Barman server. When enabled, compression is applied on the client side before sending the WAL to the Barman server. The `--compression-level` parameter allows specifying a desired compression level for the chosen algorithm. - Add --compression-level parameter to barman-cloud-wal-archive A parameter called `compression-level` was added to `barman-cloud-wal-archive`, which allows a level to be specified for the compression algorithm in use. - Add Snappy compression algorithm to Barman server The Snappy compression, previously only available in `barman-cloud-wal-archive`, is now also available for standard Barman server. As with all other algorithms, it can be configured by setting `snappy` in the `compression` configuration parameter. - Introduce the new `list-processes` sub-command for listing the server processes Add a new `list-processes` command that outputs all active subprocesses for a Barman server. The command displays each process's PID and task. - Introduce the new `terminate-process` sub-command for terminating Barman subprocesses Add a new `terminate-process` command that allows users to terminate an active Barman subprocess for a given server by specifying its task name. Barman will terminate the subprocess as long as it belongs to the specified server and it is currently active. - Remove the pin from boto3 version used in cloud scripts After thorough investigation of issues with boto3 >= 1.36, we've decided to remove the pin that kept the dependency at version 1.35. Both AWS and MinIO object stores work correctly with the latest version, and using a version of boto3 that is >= 1.36 ensures the Barman cloud scripts work in a FIPS-compliant environment. Bugfixes - Ensure minimum redundancy check considers only 'non-incremental backups' An issue was reported where the `minimum_redundancy` rule could be violated due to the inclusion of incremental backups in the redundancy count. As an example: in a scenario where the catalog contained one full backup and two dependent incremental backups, and the user had `minimum_redundancy = 2`, the rule was incorrectly considered satisfied. As a result, deleting the full backup triggered cascading deletion of its incremental dependents, leaving zero backups in the catalog. This issue has been fixed by updating the `minimum_redundancy` logic to consider only non-incremental backups (i.e. only full, rsync, snapshot). This ensures that full backups cannot be deleted if doing so would violate the configured minimum redundancy level. - Fix usage of `barman-wal-restore` with `--keep-compression` using `gzip`, `bzip2`, and `pigz` compression algorithms Fix an issue in `barman-wal-restore` where, when trying to restore WALs compressed with `gzip`, `bzip2` or `pigz` while having `--keep-compression` specified, leading to unexpected errors.
py-barman: updated to 3.13.3 3.13.3 (2025-04-24) Bugfixes - Fix local restore of block-level incremental backups When performing a local restore of block-level incremental backups, Barman was facing errors like the following: ```text ERROR: Destination directory '/home/vagrant/restore/internal_no_get_wal' must be empty ``` That error was caused by a regression when the option `--staging-wals-directory` was introduced in version 3.13.0. Along with it came a new check to ensure the WAL destination directory was empty before proceeding. However, when restoring block-level incremental backups locally, Barman was setting up the WAL destination directory before performing this check, triggering the error above. References: BAR-655. - Fix regression when running `barman-cloud-backup` as a hook Barman 3.13.2 changed the location of the `backup.info` metadata file as part of the work delivered to fix issues in WORM environments. However, those changes introduced a regression when using `barman-cloud-backup` as a backup hook in the Barman server: the hook was not aware of the new location of the metadata file. This update fixes that issue, so `barman-cloud-backup` becomes aware of the new folder structure, and properly locates the `backup.info` file, avoiding runtime failures. References: BAR-696. - Avoid decompressing partial WAL files when custom compression is configured Fixed an issue where Barman attempted to decompress partial WAL files when custom compression was configured. Partial WAL files are never compressed, so any attempt to decompress them is incorrect and caused errors when using the `--partial` flag with `barman-wal-restore` or `barman get-wal`. References: BAR-697. - Fixed `barman-cloud-backup` not recycling temporary part files This fixes a `barman-cloud-backup` problem where temporary part files were not deleted after being uploaded to the cloud, leading to disk space exhaustion. The issue happened only when using Python >= 3.12 and it was due to a change in Python that removed the `delete` attribute of named-temporary file objects, which Barman used to rely on when performing internal checks. References: BAR-674. - Fixed backup annotations usage in WORM environments Barman previously stored backup annotation files, used to track operations like `barman keep` and `barman delete`, inside the backup directory itself. These annotations help determine whether a backup should be kept or marked for deletion. However, in WORM environments, files in the backup directory cannot be modified or deleted after a certain period, which caused issues with managing backup states. This fix relocates annotation files to a dedicated metadata directory, as to ensure that such operations function correctly in WORM environments. References: BAR-663.
py-barman: updated to 3.13.2 3.13.2 (2025-03-27) Minor changes - Fix errors when using an immutable storage Added a new `worm_mode` configuration to enable WORM (Write Once Read Many) handling in Barman, allowing it to support backups on immutable storage. This fix also provides automatic relocation of the backup.info file in a new directory `meta` inside `backup_directory`. This will let Barman update it in future when needed. Barman will also _not_ purge the wals directory for WAL files that are not needed when running the first backup. This will add some extra space which will be reclaimed when this first backup is obsolete and removed (by that time, the backups and the WALs will be outside the retention policy window). Added additional notes to the documentation explaining limitations when running with an immutable storage for backups. In particular the need for a grace period in the immutability of files and the fact that `barman keep` is not supported in these environments. References: BAR-649, BAR-645, BAR-650, BAR-651, BAR-652. 3.13.1 (2025-03-20) Minor changes - Improve behavior of the backup shortcuts `last-full` / `latest-full` The shortcuts `last-full` / `latest-full` were retrieving not the last full backup of the server, but the last full backup of the server which was eligible as the parent for an incremental backup. While this was the expected behavior, the feedback from the community has shown that it was confusing for the users. From now on, the shortcuts `last-full` / `latest-full` will retrieve the last full backup of the Barman server, independently if that backup is eligible as the parent for an incremental backup or not. The eligibility of the full backup as the parent of an incremental backup will still be validated by Barman in a later step, and a proper message will be displayed in case it doesn't suit as a parent.
py-barman: updated to 3.13.0
3.13.0 (2025-02-20)
Notable changes
- Add new xlogdb_directory configuration
Introduces a new `xlogdb_directory` configuration option. This parameter can be
set either globally or per-server, and allows you to specify a custom directory
for the `xlog.db` file. This file stores metadata of archived WAL files and is used
internally by Barman in various scenarios. If unset, it defaults to the value of
`wals_directory`. Additionally, the file was also renamed to contain the server name
as a prefix.
- Make "backup_id" optional when restoring a backup
Historically, Barman always required a "backup_id" to restore a backup, and would
use that backup as the source for the restore.
This feature removes the need for specifying which backup to use as a source for
restore, making it optional.
This change applies to both Barman and the barman-cloud scripts.
Now the user is able to restore a backup in the following ways:
1. Provide a "backup_id"
2. Do not provide a "backup_id". It will retrieve the most recent backup
3. Do not provide a "backup_id", but provide a recovery target, such as:
- "target_time" (mutually exclusive with target_lsn)
Will get the closest backup prior to the "target_time"
- "target_lsn" (mutually exclusive with "target_time")
Will get the closest backup prior to the "target_lsn"
- "target_tli" (can be used combined with "target_time" or "target_lsn")
Will get the most recent backup that matches the timeline. If combined with
other recovery targets, it will get the most recent backup prior to the
target_time or target_lsn that matches the timeline
The recovery targets `--target-xid`, `--target-name` and `--target-immediate`
are not supported, and will error out with a message if used.
This feature will provide flexibility and ease when restoring a postgres cluster.
Minor changes
- Add current active model to `barman show-server` and `barman status`
Previously, after applying a configuration model, the only way to check
which model is currently active for a server was via the `barman diagnose`
command. With this update, the `barman status` and `barman show-server`
commands now also display the current active configuration model for a
server, if any.
- Add `--staging-wal-directory` option to `barman restore` command to allow alternative WAL directory on PITR
A new command line option `--staging-wal-directory` was added to the `restore`/`recover`
command to allow an alternative destination directory for WAL files when performing
PITR. Previously, WAL files were copied to a `barman_wal` directory within
the restore destination directory. This enhancement provides greater flexibility, such as
storing WALs on separate partitions during recovery.
- Pin boto3 version to any version <= 1.35.99
Boto3 version 1.36 has changed the way S3 integrity is checked making this version
incompatible with the current Barman code, generating the following error:
An error occurred (MissingContentLength) when calling the PutObject operation
As a temporary workaround, the version for boto3 is pinned to any version <= 1.35.99
until support for 1.36 is implemented in Barman.
- Make barman-wal-archive smarter when dealing with duplicate WAL files
Under some corner cases, Postgres could attempt to archive the same WAL twice.
For example: if `barman-wal-archive` copies the WAL file over to the Barman host,
but the script is interrupted before reporting success to Postgres. New executions
of `barman-wal-archive` could fail when trying to archive the same file again
because the WAL was already copied from Postgres to Barman, but not yet processed by
the asynchronous Barman WAL archiver.
This minor change deals with this situation by verifying the checksum of the
existing and the incoming file. If the checksums match the incoming file is
ignored, otherwise an output info message is sent and the incoming file is moved to
the errors directory. The code will exit with 0 in both situations, avoiding WALs
piling up in the Postgres host due to a failing `archive_command`.
- Document procedure to clear WAL archive failure check
While redesigning the Barman docs we missed adding a note advising
users to run a `switch-wal` command if the server is idle and
`barman check` returns a failure on "WAL archiving".
This addresses the gap left from the previous documentation.
- Delete WALs by deleting the entire directory at once, when possible
Previously, when WAL files needed to be deleted (e.g., due to deletion of a backup),
Barman would iterate over every WAL file and delete them individually. This could
cause performance issues, mainly in systems which use ZFS filesystem. With this
change, the entire directory will be deleted whenever noticed that all files in
the directory are no longer needed by Barman.
- Add support for `DefaultAzureCredential` option on Azure authentication
Users can now explicitly use Azure's `DefaultAzureCredential` for authentication
by using the `default` option for `azure_credential` in the server configuration
or the `--azure-credential default` option in the case of `barman-cloud-*`.
Previously, that could only be set as a fallback when no credential was provided
and no environment variables were set.
- Improve diagnose output for retention policy info
Improves the output of the barman diagnose command to display a more user-friendly
string representations. Specifically, "REDUNDANCY 2" is shown instead of
"redundancy 2 b" for the 'retention_policy' attribute, and "MAIN" is shown instead
of "simple-wal 2 b" for the 'wal_retention_policy' attribute.
Bugfixes
- Fix PITR when using `barman restore` with `--target-tli`
Barman was not creating the `recovery.signal` nor filling `recovery_target_timeline`
in `postgresql.auto.conf` in these cases:
* The only recovery target passed to `barman restore` was `--target-tli`; or
* `--target-tli` was specified with some other `--target-*` option, but the
specified target timeline was the same as the timeline of the chosen backup.
Now, if any `--target-*` option is passed to `barman restore`, that will be
correctly treated as PITR.
- Fix bug when AWS 'profile' variable is referenced before assignment
An issue was introduced by BAR-242 as part of the Barman 3.12.0 release.
The issue was causing `barman-cloud-backup-delete` (and possibly other
commands) to fail with errors like this when `--aws-profile` argument or
`aws_profile` configuration were not set:
```bash
ERROR: Barman cloud backup delete exception: local
variable 'profile' referenced before assignment`
```
- Fix --zstd flag on barman-cloud-wal-archive
Fixed a bug with the `--zstd` flag on `barman-cloud-wal-archive` where it was
essentially being ignored and not really compressing the WAL file before upload.
py-barman: updated to 3.12.1 3.12.1 (2024-12-09) Bugfixes Add isoformat fields for backup start and end times in json output This patch modifies the json output of the infofile object adding two new fields: begin_time_iso and end_time_iso. The new fields allow the use of a more standard and timezone aware time format, preserving compatibility with previous versions. It is worth noting that in the future the iso format for dates will be the standard used by barman for storing dates and will be used everywhere non human readable output is requested. As part of the work, this patch reverts BAR-316, which was introduced on Barman 3.12.0.
py-*: remove unused tool dependency py-setuptools includes the py-wheel functionality nowadays
py-barman: updated to 3.11.1
Version 3.11.1 - 22 August 2024
- Bug fixes:
- Fix failures in `barman-cloud-backup-delete`. This command was failing when
applying retention policies due to a bug introduced by the previous release.
Version 3.11.0 - 22 August 2024
- Add support for Postgres 17+ incremental backups. This major feature is
composed of several small changes:
- Add `--incremental` command-line option to `barman backup` command. This is
used to specify the parent backup when taking an incremental backup. The
parent can be either a full backup or another incremental backup.
- Add `latest-full` shortcut backup ID. Along with `latest`, this can be used
as a shortcut to select the parent backup for an incremental backup. While
`latest` takes the latest backup independently if it is full or incremental,
`latest-full` takes the latest full backup.
- `barman keep` command can only be applied to full backups when
`backup_method = postgres`. If a full backup has incremental backups that
depend on it, all of the incrementals are also kept by Barman.
- When deleting a backup all the incremental backups depending on it, if any,
are also removed.
- Retention policies do not take incremental backups into consideration. As
incremental backups cannot be recovered without having the complete chain of
backups available up to the full backup, only full backups account for
retention policies.
- `barman recover` needs to combine the full backup with the chain of incremental
backups when recovering. The new CLI option `--local-staging-path`, and the
corresponding `local_staging_path` configuration option, are used to specify
the path in the Barman host where the backups will be combined when recovering
an incremental backup.
- Changes to `barman show-backup` output:
- Add the “Estimated cluster size” field. It's useful to have an estimation
of the data directory size of a cluster when restoring a backup. It’s
particularly useful when recovering compressed backups or incremental
backups, situations where the size of the backup doesn’t reflect the size of the
data directory in Postgres. In JSON format, this is stored as
`cluster_size`.
- Add the “WAL summarizer” field. This field shows if `summarize_wal` was
enabled in Postgres at the time the backup was taken. In JSON format, this
is stored as `server_information.summarize_wal`. This field is omitted for
Postgres 16 and older.
- Add “Data checksums” field. This shows if `data_checkums` was enabled in
Postgres at the time the backup was taken. In JSON format, this is stored as
`server_information.data_checksums`.
- Add the “Backup method” field. This shows the backup method used for this
backup. In JSON format, this is stored as
`base_backup_information.backup_method`.
- Rename the field “Disk Usage” as “Backup Size”. The latter provides a more
comprehensive name which represents the size of the backup in the Barman
host. The JSON field under `base_backup_information` was also renamed from
`disk_usage` to `backup_size`.
- Add the “WAL size” field. This shows the size of the WALs required by the
backup. In JSON format, this is stored as
`base_backup_information.wal_size`.
- Refactor the field “Incremental size”. It is now named “Resources saving”
and it now shows an estimation of resources saved when taking incremental
backups with `rsync` or `pg_basebackup`. It compares the backup size with
the estimated cluster size to estimate the amount of disk and network
resources that were saved by taking an incremental backup. In JSON format,
the field was renamed from `incremental_size` to `resource_savings` under `base_backup_information`.
- Add the `system_id` field to the JSON document. This field contains the
system identifier of Postgres. It was present in console format, but was
missing in JSON format.
- Add fields related with Postgres incremental backups:
- “Backup type”: indicates if the Postgres backup is full or incremental. In
JSON format, this is stored as `backup_type` under `base_backup_information`.
- “Root backup”: the ID of the full backup that is the root of a chain of
one or more incremental backups. In JSON format, this is stored as
`catalog_information.root_backup_id`.
- “Parent backup”: the ID of the full or incremental backup from which this
incremental backup was taken. In JSON format, this is stored as
`catalog_information.parent_backup_id`.
- “Children Backup(s)”: the IDs of the incremental backups that were taken
with this backup as the parent. In JSON format, this is stored as
`catalog_information.children_backup_ids`.
- “Backup chain size”: the number of backups in the chain from this
incremental backup up to the root backup. In JSON format, this is
stored as `catalog_information.chain_size`.
- Changes to `barman list-backup` output:
- It now includes the backup type in the JSON output, which can be either
`rsync` for backups taken with rsync, `full` or `incremental` for backups
taken with `pg_basebackup`, or `snapshot` for cloud snapshots. When printing
to the console the backup type is represented by the corresponding labels
`R`, `F`, `I` or `S`.
- Remove tablespaces information from the output. That was bloating the
output. Tablespaces information can still be found in the output of
`barman show-backup`.
- Always set a timestamp with a time zone when configuring
`recovery_target_time` through `barman recover`. Previously, if no time zone
was explicitly set through `--target-time`, Barman would configure
`recovery_target_time` without a time zone in Postgres. Without a time zone,
Postgres would assume whatever is configured through `timezone` GUC in
Postgres. From now on Barman will issue a warning and configure
`recovery_target_time` with the time zone of the Barman host if no time zone
is set by the user through `--target-time` option.
- When recovering a backup with the “no get wal” approach and `--target-lsn` is set,
copy only the WAL files required to reach the configured target. Previously
Barman would copy all the WAL files from its archive to Postgres.
- When recovering a backup with the “no get wal” approach and `--target-immediate`
is set, copy only the WAL files required to reach the consistent point.
Previously Barman would copy all the WAL files from its archive to Postgres.
- `barman-wal-restore` now moves WALs from the spool directory to `pg_wal`
instead of copying them. This can improve performance if the spool directory
and the `pg_wal` directory are in the same partition.
- `barman check-backup` now shows the reason why a backup was marked as `FAILED`
in the output and logs. Previously for a user to know why the backup was
marked as `FAILED`, they would need to run `barman show-backup` command.
- Add configuration option `aws_await_snapshots_timeout` and the corresponding
`--aws-await-snapshots-timeout` command-line option on `barman-cloud-backup`.
This specifies the timeout in seconds to wait for snapshot backups to reach
the completed state.
- Add a keep-alive mechanism to rsync-based backups. Previously the Postgres
session created by Barman to run `pg_backup_start()` and `pg_backup_stop()` would
stay idle for as long as the base backup copy would take. That could lead to a
firewall or router dropping the connection because it was idle for a long
time. The keep-alive mechanism sends heartbeat queries to Postgres
through that connection, thus reducing the likelihood of a connection
getting dropped. The interval between heartbeats can be controlled through the new
configuration option `keepalive_interval` and the corresponding CLI
option `--keepalive-interval` of the `barman backup` command.
- Bug fixes:
- When recovering a backup with the “no get wal” approach and `--target-time`
set, copy all WAL files. Previously Barman would attempt to “guess” the WAL
files required by Postgres to reach the configured target time. However,
the mechanism was not robust enough as it was based on the stats of the WAL
file in the Barman host (more specifically the creation time). For example:
if there were archiving or streaming lag between Postgres and Barman, that
could be enough for recovery to fail because Barman would miss to copy all
the required WAL files due to the weak check based on file stats.
- Pin `python-snappy` to `0.6.1` when running Barman through Python 3.6 or
older. Newer versions of `python-snappy` require `cramjam` version `2.7.0` or
newer, and these are only available for Python 3.7 or newer.
- `barman receive-wal` now exits with code `1` instead of `0` in the following
cases:
- Being unable to run with `--reset` flag because `pg_receivewal` is
running.
- Being unable to start `pg_receivewal` process because it is already
running.
- Fix and improve information about Python in `barman diagnose` output:
- The command now makes sure to use the same Python interpreter under which
Barman is installed when outputting the Python version through
`python_ver` JSON key. Previously, if an environment had multiple Python
installations and/or virtual environments, the output could eventually be
misleading, as it could be fetched from a different Python interpreter.
- Added a `python_executable` key to the JSON output. That contains the path
to the exact Python interpreter being used by Barman.
py-barman: updated to 3.10.1
Version 3.10.1 - 12 June 2024
- Bug fixes:
- Make `argcomplete` optional to avoid installation issues on some
platforms.
- Load `barman.auto.conf` only when the file exists.
- Emit a warning when the `cfg_changes.queue` file is malformed.
- Correct in documentation the postgresql version where
`pg_checkpoint` is available.
- Add `--no-partial` option to `barman-cloud-wal-restore`.
py-barman: updated to 3.10.0
Version 3.10.0 - 24 January 2024
- Limit the average bandwidth used by `barman-cloud-backup` when backing
up to either AWS S3 or Azure Blob Storage according to the value set by
a new CLI option `--max-bandwidth`.
- Add the new configuration option `lock_directory_cleanup`
That enables cron to automatically clean up the barman_lock_directory
from unused lock files.
- Add support for a new type of configuration called `model`.
The model acts as a set of overrides for configuration options
for a given Barman server.
- Add a new barman command `barman config-update` that allows the creation
and the update of configurations using JSON
- Bug fixes:
- Fix a bug that caused `--min-chunk-size` to be ignored when using
barman-cloud-backup as hook script in Barman.
Version 3.9.0 - 3 October 2023
- Allow `barman switch-wal --force` to be run against PG>=14 if the
user has the `pg_checkpoint` role (thanks to toydarian for this patch).
- Log the current check at `info` level when a check timeout occurs.
- The minimum size of an upload chunk when using `barman-cloud-backup`
with either S3 or Azure Blob Storage can now be specified using the
`--min-chunk-size` option.
- `backup_compression = none` is supported when using `pg_basebackup`.
- For PostgreSQL 15 and later: the allowed `backup_compression_level`
values for `zstd` and `lz4` have been updated to match those allowed by
`pg_basebackup`.
- For PostgreSQL versions earlier than 15: `backup_compression_level = 0`
can now be used with `backup_compression = gzip`.
- Bug fixes:
- Fix `barman recover` on platforms where Multiprocessing uses spawn by
default when starting new processes.
Version 3.8.0 - 31 August 2023
- Clarify package installation. barman is packaged with default python version
for each operating system.
- The `minimum-redundancy` option is added to `barman-cloud-backup-delete`.
It allows to set the minimum number of backups that should always be available.
- Add a new `primary_checkpoint_timeout` configuration option. Allows define
the amount of seconds that Barman will wait at the end of a backup if no
new WAL files are produced, before forcing a checkpoint on the primary server.
- Bug fixes:
- Fix race condition in barman retention policies application. Backup
deletions will now raise a warning if another deletion is in progress
for the requested backup.
- Fix `barman-cloud-backup-show` man page installation.
py-barman: restrict to python 3
py-barman: updated to 2.19
Version 2.19 - 9 March 2022
- Change `barman diagnose` output date format to ISO8601.
- Add Google Cloud Storage (GCS) support to barman cloud.
- Support `current` and `latest` recovery targets for the `--target-tli`
option of `barman recover`.
- Add documentation for installation on SLES.
- Bug fixes:
- `barman-wal-archive --test` now returns a non-zero exit code when
an error occurs.
- Fix `barman-cloud-check-wal-archive` behaviour when `-t` option is
used so that it exits after connectivity test.
- `barman recover` now continues when `--no-get-wal` is used and
`"get-wal"` is not set in `recovery_options`.
- Fix `barman show-servers --format=json ${server}` output for
inactive server.
- Check for presence of `barman_home` in configuration file.
- Passive barman servers will no longer store two copies of the
tablespace data when syncing backups taken with
`backup_method = postgres`.
- We thank richyen for his contributions to this release.
Version 2.18 - 21 January 2022
- Add snappy compression algorithm support in barman cloud (requires the
optional python-snappy dependency).
- Allow Azure client concurrency parameters to be set when uploading
WALs with barman-cloud-wal-archive.
- Add `--tags` option in barman cloud so that backup files and archived
WALs can be tagged in cloud storage (aws and azure).
- Update the barman cloud exit status codes so that there is a dedicated
code (2) for connectivity errors.
- Add the commands `barman verify-backup` and `barman generate-manifest`
to check if a backup is valid.
- Add support for Azure Managed Identity auth in barman cloud which can
be enabled with the `--credential` option.
- Bug fixes:
- Change `barman-cloud-check-wal-archive` behavior when bucket does
not exist.
- Ensure `list-files` output is always sorted regardless of the
underlying filesystem.
- Man pages for barman-cloud-backup-keep, barman-cloud-backup-delete
and barman-cloud-check-wal-archive added to Python packaging.
- We thank richyen and stratakis for their contributions to this
release.
Version 2.17 - 1 December 2021
- Bug fixes:
- Resolves a performance regression introduced in version 2.14 which
increased copy times for `barman backup` or `barman recover` commands
when using the `--jobs` flag.
- Ignore rsync partial transfer errors for `sender` processes so that
such errors do not cause the backup to fail (thanks to barthisrael).
Version 2.16 - 17 November 2021
- Add the commands `barman-check-wal-archive` and `barman-cloud-check-wal-archive`
to validate if a proposed archive location is safe to use for a new PostgreSQL
server.
- Allow Barman to identify WAL that's already compressed using a custom
compression scheme to avoid compressing it again.
- Add `last_backup_minimum_size` and `last_wal_maximum_age` options to
`barman check`.
- Bug fixes:
- Use argparse for command line parsing instead of the unmaintained
argh module.
- Make timezones consistent for `begin_time` and `end_time`.
- We thank chtitux, George Hansper, stratakis, Thoro, and vrms for their
contributions to this release.
Version 2.15 - 12 October 2021
- Add plural forms for the `list-backup`, `list-server` and
`show-server` commands which are now `list-backups`, `list-servers`
and `show-servers`. The singular forms are retained for backward
compatibility.
- Add the `last-failed` backup shortcut which references the newest
failed backup in the catalog so that you can do:
- `barman delete <SERVER> last-failed`
- Bug fixes:
- Tablespaces will no longer be omitted from backups of EPAS
versions 9.6 and 10 due to an issue detecting the correct version
string on older versions of EPAS.
Version 2.14 - 22 September 2021
- Add the `barman-cloud-backup-delete` command which allows backups in
cloud storage to be deleted by specifying either a backup ID or a
retention policy.
- Allow backups to be retained beyond any retention policies in force by
introducing the ability to tag existing backups as archival backups
using `barman keep` and `barman-cloud-backup-keep`.
- Allow the use of SAS authentication tokens created at the restricted
blob container level (instead of the wider storage account level) for
Azure blob storage
- Significantly speed up `barman restore` into an empty directory for
backups that contain hundreds of thousands of files.
- Bug fixes:
- The backup privileges check will no longer fail if the user lacks
"userepl" permissions and will return better error messages if any
required permissions are missing
Version 2.13 - 26 July 2021
- Add Azure blob storage support to barman-cloud
- Support tablespace remapping in barman-cloud-restore via
`--tablespace name:location`
- Allow barman-cloud-backup and barman-cloud-wal-archive to run as
Barman hook scripts, to allow data to be relayed to cloud storage
from the Barman server
- Bug fixes:
- Stop backups failing due to idle_in_transaction_session_timeout
(https://github.com/EnterpriseDB/barman/issues/333)
- Fix a race condition between backup and archive-wal in updating
xlog.db entries
- Handle PGDATA being a symlink in barman-cloud-backup, which led to
"seeking backwards is not allowed" errors on restore
- Recreate pg_wal on restore if the original was a symlink
- Recreate pg_tblspc symlinks for tablespaces on restore
- Make barman-cloud-backup-list skip backups it cannot read, e.g.,
because they are in Glacier storage
- Add `-d database` option to barman-cloud-backup to specify which
database to connect to initially
- Fix "Backup failed uploading data" errors from barman-cloud-backup
on Python 3.8 and above, caused by attempting to pickle the boto3
client
- Correctly enable server-side encryption in S3 for buckets that do
not have encryption enabled by default.
In Barman 2.12, barman-cloud-backup's `--encryption` option did
not correctly enable encryption for the contents of the backup if
the backup was stored in an S3 bucket that did not have encryption
enabled. If this is the case for you, please consider deleting
your old backups and taking new backups with Barman 2.13.
If your S3 buckets already have encryption enabled by default
(which we recommend), this does not affect you.
Version 2.12.1 - 30 June 2021
- Bug fixes:
- Allow specifying target-tli with other target-* recovery options
- Fix incorrect NAME in barman-cloud-backup-list manpage
- Don't raise an error if SIGALRM is ignored
- Fetch wal_keep_size, not wal_keep_segments, from Postgres 13
Version 2.12 - 5 Nov 2020
- Introduce a new backup_method option called local-rsync which
targets those cases where Barman is installed on the same server
where PostgreSQL is and directly uses rsync to take base backups,
bypassing the SSH layer.
- Bug fixes:
- Avoid corrupting boto connection in worker processes
- Avoid connection attempts to PostgreSQL during tests
python: egg.mk: add USE_PKG_RESOURCES flag This flag should be set for packages that import pkg_resources and thus need setuptools after the build step. Set this flag for packages that need it and bump PKGREVISION.
*: bump PKGREVISION for egg.mk users They now have a tool dependency on py-setuptools instead of a DEPENDS
py-barman: Update to 2.11.
Version 2.11 - 9 Jul 2020
- Introduction of the barman-cli-cloud package that contains all cloud
related utilities.
- Add barman-cloud-wal-restore to restore a WAL file previously
archived with barman-cloud-wal-archive from an object store
- Add barman-cloud-restore to restore a backup previously taken with
barman-cloud-backup from an object store
- Add barman-cloud-backup-list to list backups taken with
barman-cloud-backup in an object store
- Add support for arbitrary archive size for barman-cloud-backup
- Add support for --endpoint-url option to cloud utilities
- Remove strict superuser requirement for PG 10+ (by Kaarel Moppel)
- Add --log-level runtime option for barman to override default log
level for a specific command
- Support for PostgreSQL 13
- Bug fixes:
- Suppress messages and warning with SSH connections in barman-cli
(GH-257)
- Fix a race condition when retrieving uploaded parts in
barman-cloud-backup (GH-259)
- Close the PostgreSQL connection after a backup (GH-258)
- Check for uninitialized replication slots in receive-wal --reset
(GH-260)
- Ensure that begin_wal is valorised before acting on it (GH-262)
- Fix bug in XLOG/WAL arithmetic with custom segment size (GH-287)
- Fix rsync compatibility error with recent rsync
- Fix PostgreSQLClient version parsing
- Fix PostgreSQL exception handling with non ASCII messages
- Ensure each postgres connection has an empty search_path
- Avoid connecting to PostgreSQL while reading a backup.info file
If you are using already barman-cloud-wal-archive or barman-cloud-backup
installed via RPM/Apt package and you are upgrading your system, you
must install the barman-cli-cloud package. All cloud related tools are
now part of the barman-cli-cloud package, including
barman-cloud-wal-archive and barman-cloud-backup that were previosly
shipped with barman-cli. The reason is complex dependency management of
the boto3 library, which is a requirement for the cloud utilities.
Version 2.10 - 5 Dec 2019
- Pull .partial WAL files with get-wal and barman-wal-restore,
allowing restore_command in a recovery scenario to fetch a partial
WAL file's content from the Barman server. This feature simplifies
and enhances RPO=0 recovery operations.
- Store the PostgreSQL system identifier in the server directory and
inside the backup information file. Improve check command to verify
the consistency of the system identifier with active connections
(standard and replication) and data on disk.
- A new script called barman-cloud-wal-archive has been added to the
barman-cli package to directly ship WAL files from PostgreSQL (using
archive_command) to cloud object storage services that are
compatible with AWS S3. It supports encryption and compression.
- A new script called barman-cloud-backup has been added to the
barman-cli package to directly ship base backups from a local
PostgreSQL server to cloud object storage services that are
compatible with AWS S3. It supports encryption, parallel upload,
compression.
- Automated creation of replication slots through the server/global
option create_slot. When set to auto, Barman creates the replication
slot, in case streaming_archiver is enabled and slot_name is
defined. The default value is manual for back-compatibility.
- Add '-w/--wait' option to backup command, making Barman wait for all
required WAL files to be archived before considering the backup
completed. Add also the --wait-timeout option (default 0, no
timeout).
- Redact passwords from Barman output, in particular from
barman diagnose (InfoSec)
- Improve robustness of receive-wal --reset command, by verifying that
the last partial file is aligned with the current location or, if
present, with replication slot's.
- Documentation improvements
- Bug fixes:
- Wrong string matching operation when excluding tablespaces
inside PGDATA (GH-245)
- Minor fixes in WAL delete hook scripts (GH-240)
- Fix PostgreSQL connection aliveness check (GH-239)
Version 2.9 - 1 Aug 2019
- Transparently support PostgreSQL 12, by supporting the new way of
managing recovery and standby settings through GUC options and
signal files (recovery.signal and standby.signal)
- Add --bwlimit command line option to set bandwidth limitation for
backup and recover commands
- Ignore WAL archive failure for check command in case the latest
backup is WAITING_FOR_WALS
- Add --target-lsn option to set recovery target Log Sequence Number
for recover command with PostgreSQL 10 or higher
- Add --spool-dir option to barman-wal-restore so that users can
change the spool directory location from the default, avoiding
conflicts in case of multiple PostgreSQL instances on the same
server (thanks to Drazen Kacar).
- Rename barman_xlog directory to barman_wal
- JSON output writer to export command output as JSON objects and
facilitate integration with external tools and systems (thanks to
Marcin Onufry Hlybin). Experimental in this release.
Bug fixes:
- replication-status doesn’t show streamers with no slot (GH-222)
- When checking that a connection is alive (“SELECT 1” query),
preserve the status of the PostgreSQL connection (GH-149). This
fixes those cases of connections that were terminated due to
idle-in-transaction timeout, causing concurrent backups to fail.
Version 2.8 - 17 May 2019
- Add support for reuse_backup in geo-redundancy for incremental
backup copy in passive nodes
- Improve performance of rsync based copy by using strptime instead of
the more generic dateutil.parser (#210)
- Add ‘--test’ option to barman-wal-archive and barman-wal-restore to
verify the connection with the Barman server
- Complain if backup_options is not explicitly set, as the future
default value will change from exclusive_backup to concurrent_backup
when PostgreSQL 9.5 will be declared EOL by the PGDG
- Display additional settings in the show-server and diagnose
commands: archive_timeout, data_checksums, hot_standby,
max_wal_senders, max_replication_slots and wal_compression.
- Merge the barman-cli project in Barman
- Bug fixes:
- Fix encoding error in get-wal on Python 3 (Jeff Janes, #221)
- Fix exclude_and_protect_filter (Jeff Janes, #217)
- Remove spurious message when resetting WAL (Jeff Janes, #215)
- Fix sync-wals error if primary has WALs older than the first
backup
- Support for double quotes in synchronous_standby_names setting
- Minor changes:
- Improve messaging of check --nagios for inactive servers
- Log remote SSH command with recover command
- Hide logical decoding connections in replication-status command
This release officially supports Python 3 and deprecates Python 2 (which
might be discontinued in future releases).
PostgreSQL 9.3 and older is deprecated from this release of Barman.
Support for backup from standby is now limited to PostgreSQL 9.4 or
higher and to WAL shipping from the standby (please refer to the
documentation for details).
Version 2.7 - 21 Mar 2019
- Fix error handling during the parallel backup. Previously an
unrecoverable error during the copy could have corrupted the barman
internal state, requiring a manual kill of barman process with
SIGTERM and a manual cleanup of the running backup in PostgreSQL.
(GH#199)
- Fix support of UTF-8 characters in input and output (GH#194 and
GH#196)
- Ignore history/backup/partial files for first sync of geo-redundancy
(GH#198)
- Fix network failure with geo-redundancy causing cron to break
(GH#202)
- Fix backup validation in PostgreSQL older than 9.2
- Various documentation fixes
Version 2.6 - 4 Feb 2019
- Add support for Geographical redundancy, introducing 3 new commands:
sync-info, sync-backup and sync-wals. Geo-redundancy allows a Barman
server to use another Barman server as data source instead of a
PostgreSQL server.
- Add put-wal command that allows Barman to safely receive WAL files
via PostgreSQL's archive_command using the barman-wal-archive script
included in barman-cli
- Add ANSI colour support to check command
- Minor fixes:
- Fix switch-wal on standby with an empty WAL directory
- Honour archiver locking in wait_for_wal method
- Fix WAL compression detection algorithm
- Fix current_action in concurrent stop backup errors
- Do not treat lock file busy as an error when validating a backup
*: reset MAINTAINER for fhajny on his request
all: migrate homepages from http to https pkglint -r --network --only "migrate" As a side-effect of migrating the homepages, pkglint also fixed a few indentations in unrelated lines. These and the new homepages have been checked manually.
py-barman: updated to 2.5
Version 2.5:
- Add support for PostgreSQL 11
- Add check-backup command to verify that WAL files required for
consistency of a base backup are present in the archive. Barman now
adds a new state (WAITING_FOR_WALS) after completing a base backup,
and sets it to DONE once it has verified that all WAL files from
start to the end of the backup exist. This command is included in
the regular cron maintenance job. Barman now notifies users
attempting to recover a backup that is in WAITING_FOR_WALS state.
- Allow switch-xlog --archive to work on a standby (just for the
archive part)
- Bug fixes:
- Fix decoding errors reading external commands output
- Fix documentation regarding WAL streaming and backup from
standby
*: update email for fhajny
py-barman: updated to 2.4
Version 2.4:
- Add standard and retry hook scripts for backup deletion (pre/post)
- Add standard and retry hook scripts for recovery (pre/post)
- Add standard and retry hook scripts for WAL deletion (pre/post)
- Add --standby-mode option to barman recover to add standby_mode = on
in pre-generated recovery.conf
- Add --target-action option to barman recover, allowing users to add
shutdown, pause or promote to the pre-generated recovery.conf file
- Improve usability of point-in-time recovery with consistency checks
(e.g. recovery time is after end time of backup)
- Minor documentation improvements
- Drop support for Python 3.3
Relevant bug fixes:
- Fix remote get_file_content method, preventing
incremental recovery from happening
- Unicode issues with command
- Add --wal-method=none when pg_basebackup >= 10
Minor bug fixes:
- Stop process manager module from ovewriting lock files content
- Relax the rules for rsync output parsing
- Ignore vanished files in streaming directory
- Case insensitive slot names
- Make DataTransferFailure.from_command_error() more resilient
- Rename command() to barman_command()
- Initialise synchronous standby names list if not set
- Correct placeholders ordering
- Force datestyle to iso for replication connections
- Returns error if delete command does not remove the backup
- Fix exception when calling is_power_of_two(None)
- Downgraded sync standby names messages to debug
Version 2.3:
- Add support to PostgreSQL 10
- Follow naming changes in PostgreSQL 10:
- The switch-xlog command has been renamed to switch-wal.
- In commands output, the xlog word has been changed to WAL and
location has been changed to LSN when appropriate.
- Add the --network-compression/--no-network-compression options to
barman recover to enable or disable network compression at run-time
- Add --target-immediate option to recover command, in order to exit
recovery when a consistent state is reached (end of the backup,
available from PostgreSQL 9.4)
- Show cluster state (master or standby) with barman status command
- Documentation improvements
- Bug fixes:
- Fix high memory usage with parallel_jobs > 1
- Better handling of errors using parallel copy
- Make barman diagnose more robust with system exceptions
- Let archive-wal ignore files with .tmp extension
Version 2.2:
- Implement parallel copy for backup/recovery through the
parallel_jobs global/server option to be overridden by the --jobs or
-j runtime option for the backup and recover command. Parallel
backup is available only for the rsync copy method. By default, it
is set to 1 (for behaviour compatibility with previous versions).
- Support custom WAL size for PostgreSQL 8.4 and newer. At backup
time, Barman retrieves from PostgreSQL wal_segment_size and
wal_block_size values and computes the necessary calculations.
- Improve check command to ensure that incoming directory is empty
when archiver=off, and streaming directory is empty when
streaming_archiver=off
- Add external_configuration to backup_options so that users can
instruct Barman to ignore backup of configuration files when they
are not inside PGDATA (default for Debian/Ubuntu installations). In
this case, Barman does not display a warning anymore.
- Add --get-wal and --no-get-wal options to barman recover
- Add max_incoming_wals_queue global/server option for the check
command so that a non blocking error is returned in case incoming
WAL directories for both archiver and the streaming_archiver contain
more files than the specified value.
- Documentation improvements
- File format changes:
- The format of backup.info file has changed. For this reason a
backup taken with Barman 2.2 cannot be read by a previous
version of Barman. But, backups taken by previous versions can
be read by Barman 2.2.
- Minor bug fixes:
- Allow replication-status to work against a standby
- Close any PostgreSQL connection before starting pg_basebackup
- Safely handle paths containing special characters
- Archive .partial files after promotion of streaming source
- Recursively create directories during recovery
- Improve xlog.db locking
- Remove tablespace_map file during recover
- Reconnect to PostgreSQL if connection drops
Version 2.1:
- Add --archive and --archive-timeout options to switch-xlog command
- Preliminary support for PostgreSQL 10
- Minor additions:
- Add last archived WAL info to diagnose output
- Add start time and execution time to the output of delete
command
- Minor bug fixes:
- Return failure for get-wal command on inactive server
- Make streaming_archiver_names and streaming_backup_name options
global
- Fix rsync failures due to files truncated during transfer
- Correctly handle compressed history files
- Avoid de-referencing symlinks in pg_tblspc when preparing
recovery
- Fix comparison of last archiving failure
- Avoid failing recovery if postgresql.conf is not writable
- Fix output of replication-status command
- Exclude files from backups like pg_basebackup
- Exclude directories from other Postgres versions while copying
tablespaces
- Make retry hook script options global
Version 2.0 - 27 Sep 2016
- Support for pg_basebackup and base backups over the PostgreSQL
streaming replication protocol with backup_method=postgres
(PostgreSQL 9.1 or higher required)
- Support for physical replication slots through the slot_name
configuration option as well as the --create-slot and --drop-slot
options for the receive-wal command (PostgreSQL 9.4 or higher
required). When slot_name is specified and streaming_archiver is
enabled, receive-wal transparently integrates with pg_receivexlog,
and check makes sure that slots exist and are actively used
- Support for the new backup API introduced in PostgreSQL 9.6, which
transparently enables concurrent backups and backups from standby
servers using the standard rsync method of backup. Concurrent backup
was only possible for PostgreSQL 9.2 to 9.5 versions through the
pgespresso extension. The new backup API will make pgespresso
redundant in the future
- If properly configured, Barman can function as a synchronous standby
in terms of WAL streaming. By properly setting the
streaming_archiver_name in the synchronous_standby_names priority
list on the master, and enabling replication slot support, the
receive-wal command can now be part of a PostgreSQL synchronous
replication cluster, bringing RPO=0 (PostgreSQL 9.5.5 or
higher required)
- Introduce barman-wal-restore, a standard and robust script written
in Python that can be used as restore_command in recovery.conf files
of any standby server of a cluster. It supports remote parallel
fetching of WAL files by efficiently invoking get-wal through SSH.
Currently available as a separate project called barman-cli. The
barman-cli package is required for remote recovery when get-wal is
listed in recovery_options
- Control the maximum execution time of the check command through the
check_timeout global/server configuration option (30 seconds
by default)
- Limit the number of WAL segments that are processed by an
archive-wal run, through the archiver_batch_size and
streaming_archiver_batch_size global/server options which control
archiving of WAL segments coming from, respectively, the standard
archiver and receive-wal
- Removed locking of the XLOG database during check operations
- The show-backup command is now aware of timelines and properly
displays which timelines can be used as recovery targets for a given
base backup. Internally, Barman is now capable of parsing .history
files
- Improved the logic behind the retry mechanism when copy operations
experience problems. This involves backup (rsync and postgres) as
well as remote recovery (rsync)
- Code refactoring involving remote command and physical copy
interfaces
- Bug fixes:
- Correctly handle .history files from streaming
- Fix replication-status on PostgreSQL 9.1
- Fix replication-status when sent and write locations are not
available
- Fix misleading message on pg_receivexlog termination
Switch py-dateutils to plain DEPENDS. It supports both python 2 and 3 nowadays.
Update databases/py-barman to 1.6.1. - Add --peek option to get-wal command to discover existing WAL files from the Barman's archive - Add replication-status command for monitoring the status of any streaming replication clients connected to the PostgreSQL server. The --target option allows users to limit the request to only hot standby servers or WAL streaming clients - Add the switch-xlog command to request a switch of a WAL file to the PostgreSQL server. Through the '--force' it issues a CHECKPOINT beforehand - Add streaming_archiver_name option, which sets a proper application_name to pg_receivexlog when streaming_archiver is enabled (only for PostgreSQL 9.3 and above) - Check for _superuser_ privileges with PostgreSQL's standard connections (#30) - Check the WAL archive is never empty - Check for 'backup_label' on the master when server is down - Improve barman-wal-restore contrib script - Treat the "failed backups" check as non-fatal - Rename '-x' option for get-wal as '-z' - Add archive_mode=always support for PostgreSQL 9.5 (#32) - Properly close PostgreSQL connections when necessary - Fix receive-wal for pg_receive_xlog version 9.2
Update databases/py-barman to 1.6.0.
Version 1.6.0 - 29 Feb 2016
- Support for streaming replication connection through the
streaming_conninfo server option
- Support for the streaming_archiver option that allows Barman to
receive WAL files through PostgreSQL's native streaming protocol.
When set to 'on', it relies on pg_receivexlog to receive WAL data,
reducing Recovery Point Objective. Currently, WAL streaming is an
additional feature (standard log archiving is still required)
- Implement the receive-wal command that, when streaming_archiver is
on, wraps pg_receivexlog for WAL streaming. Add --stop option to
stop receiving WAL files via streaming protocol. Add --reset option
to reset the streaming status and restart from the current xlog
in Postgres.
- Automatic management (startup and stop) of receive-wal command via
cron command
- Support for the path_prefix configuration option
- Introduction of the archiver option (currently fixed to on) which
enables continuous WAL archiving for a specific server, through log
shipping via PostgreSQL's archive_command
- Support for streaming_wals_directory and errors_directory options
- Management of WAL duplicates in archive-wal command and integration
with check command
- Verify if pg_receivexlog is running in check command when
streaming_archiver is enabled
- Verify if failed backups are present in check command
- Accept compressed WAL files in incoming directory
- Add support for the pigz compressor (thanks to Stefano Zacchiroli
zack@upsilon.cc)
- Implement pygzip and pybzip2 compressors (based on an initial idea
of Christoph Moench-Tegeder christoph@2ndquadrant.de)
- Creation of an implicit restore point at the end of a backup
- Current size of the PostgreSQL data files in barman status
- Permit archive_mode=always for PostgreSQL 9.5 servers (thanks to
Christoph Moench-Tegeder christoph@2ndquadrant.de)
- Complete refactoring of the code responsible for connecting to
PostgreSQL
- Improve messaging of cron command regarding sub-processes
- Native support for Python >= 3.3
- Changes of behaviour:
- Stop trashing WAL files during archive-wal (commit:e3a1d16)
- Bug fixes:
- Atomic WAL file archiving (#9 and #12)
- Propagate "-c" option to any Barman subprocess (#19)
- Fix management of backup ID during backup deletion (#22)
- Improve archive-wal robustness and log messages (#24)
- Improve error handling in case of missing parameters
Version 1.5.1 - 16 Nov 2015
- Add support for the 'archive-wal' command which performs WAL
maintenance operations on a given server
- Add support for "per-server" concurrency of the 'cron' command
- Improved management of xlog.db errors
- Add support for mixed compression types in WAL files (SF.net#61)
- Bug fixes:
- Avoid retention policy checks during the recovery
- Avoid 'wal_level' check on PostgreSQL version < 9.0 (#3)
- Fix backup size calculation (#5)
Update databases/py-barman to 1.5.0.
- Add support for the get-wal command which allows users to fetch any
WAL file from the archive of a specific server
- Add support for retry hook scripts, a special kind of hook scripts
that Barman tries to run until they succeed
- Add active configuration option for a server to temporarily disable
the server by setting it to False
- Add barman_lock_directory global option to change the location of
lock files (by default: 'barman_home')
- Execute the full suite of checks before starting a backup, and skip
it in case one or more checks fail
- Forbid to delete a running backup
- Analyse include directives of a PostgreSQL server during backup and
recover operations
- Add check for conflicting paths in the configuration of Barman, both
intra (by temporarily disabling a server) and inter-server (by
refusing any command, to any server).
- Add check for wal_level
- Add barman-wal-restore script to be used as restore_command on a
standby server, in conjunction with barman get-wal
- Implement a standard and consistent policy for error management
- Improved cache management of backups
- Improved management of configuration in unit tests
- Tutorial and man page sources have been converted to Markdown format
- Add code documentation through Sphinx
- Complete refactor of the code responsible for managing the backup
and the recover commands
- Changed internal directory structure of a backup
- Introduce copy_method option (currently fixed to rsync)
- Bug fixes:
- Manage options without '=' in PostgreSQL configuration files
- Preserve Timeline history files (Fixes: #70)
- Workaround for rsync on SUSE Linux (Closes: #13 and #26)
- Disables dangerous settings in postgresql.auto.conf
(Closes: #68)
- Fixed error in WAL rate calculation
Update databases/py-barman to 1.4.1.
Version 1.4.1 - 05 May 2015
* Fix for WAL archival stop working if first backup is EMPTY
(Closes: #64)
* Fix exception during error handling in Barman recovery (Closes:
#65)
* After a backup, limit cron activity to WAL archiving only
(Closes: #62)
* Improved robustness and error reporting of the backup delete
command (Closes: #63)
* Fix computation of WAL production ratio as reported in the
show-backup command
* Improved management of xlogb file, which is now correctly fsynced
when updated. Also, the rebuild-xlogdb command now operates on a
temporary new file, which overwrites the main one when finished.
* Add unit tests for dateutil module compatibility
* Modified Barman version following PEP 440 rules and added support
of tests in Python 3.4
Removing python26. EOL'd quite some ago and discussed a couple times on tech-pkg@ and pkgsrc-users@.
Update py-barman to 1.4.0.
Version 1.4.0 - 26 Jan 2015
* Incremental base backup implementation through the reuse_backup
global/server option. Possible values are off (disabled,
default), copy (preventing unmodified files from being
transferred) and link (allowing for deduplication through hard
links).
* Store and show deduplication effects when using reuse_backup=
link.
* Added transparent support of pg_stat_archiver (PostgreSQL 9.4) in
check, show-server and status commands.
* Improved administration by invoking WAL maintenance at the end of
a successful backup.
* Changed the way unused WAL files are trashed, by differentiating
between concurrent and exclusive backup cases.
* Improved performance of WAL statistics calculation.
* Treat a missing pg_ident.conf as a WARNING rather than an error.
* Refactored output layer by removing remaining yield calls.
* Check that rsync is in the system path.
* Include history files in WAL management.
* Improved robustness through more unit tests.
* Fixed bug #55: Ignore fsync EINVAL errors on directories.
* Fixed bug #58: retention policies delete.
py-argcomplete doesn't support Python 2.6.
Import Barman as databases/py-barman. Barman (Backup and Recovery Manager) is an open-source administration tool for disaster recovery of PostgreSQL servers written in Python.