xenial (1) obnam.1.gz

Provided by: obnam_1.19.1-1_amd64 bug

NAME

       obnam - make, restore, and manipulate backups

SYNOPSIS

       obnam  [--always-restore-setuid] [--no-always-restore-setuid] [--checkpoint=SIZE] [--chunk-bag-size=SIZE]
       [--chunk-cache-size=SIZE]  [--chunk-size=SIZE]   [--chunkids-per-group=NUM]   [--client-name=CLIENT-NAME]
       [--compress-with=PROGRAM]          [--config=FILE]         [--dump-config]         [--dump-setting-names]
       [--generate-manpage=TEMPLATE]    [-h]    [--help]    [--help-all]    [--list-config-files]    [--version]
       [--no-default-configs]       [--crash-limit=COUNTER]       [--critical-age=AGE]      [--deduplicate=MODE]
       [--dir-bag-size=SIZE] [--dir-cache-size=SIZE] [--dump-memory-profile=METHOD]  [--dump-repo-file-metadata]
       [--no-dump-repo-file-metadata]   [--encrypt-with=ENCRYPT-WITH]   [--exclude=EXCLUDE]   [--exclude-caches]
       [--no-exclude-caches]   [--exclude-from=FILE]   [--fsck-fix]    [--no-fsck-fix]    [--fsck-ignore-chunks]
       [--no-fsck-ignore-chunks]            [--fsck-ignore-client=NAME]            [--fsck-last-generation-only]
       [--no-fsck-last-generation-only]   [--fsck-rm-unused]    [--no-fsck-rm-unused]    [--fsck-skip-checksums]
       [--no-fsck-skip-checksums]       [--fsck-skip-dirs]       [--no-fsck-skip-dirs]       [--fsck-skip-files]
       [--no-fsck-skip-files]               [--fsck-skip-generations]               [--no-fsck-skip-generations]
       [--fsck-skip-per-client-b-trees]     [--no-fsck-skip-per-client-b-trees]     [--fsck-skip-shared-b-trees]
       [--no-fsck-skip-shared-b-trees]   [--fuse-opt=FUSE]    [--generation=GENERATION]    [--gnupghome=HOMEDIR]
       [--idpath-bits=IDPATH-BITS] [--idpath-depth=IDPATH-DEPTH] [--idpath-skip=IDPATH-SKIP] [--include=INCLUDE]
       [--keep=KEEP]     [--key-details]      [--no-key-details]      [--keyid=KEYID]      [--leave-checkpoints]
       [--no-leave-checkpoints]   [--lock-timeout=TIMEOUT]   [--log=FILE]   [--log-keep=N]   [--log-level=LEVEL]
       [--log-max=SIZE] [--log-mode=MODE] [--lru-size=SIZE] [--memory-dump-interval=SECONDS]  [--node-size=SIZE]
       [--one-file-system]    [--no-one-file-system]    [--output=FILE]   [--pretend]   [--dry-run]   [--no-act]
       [--no-pretend]     [--no-dry-run]     [--no-no-act]     [--pretend-time=TIMESTAMP]      [--pure-paramiko]
       [--no-pure-paramiko]   [--quiet]   [--silent]   [--no-quiet]   [--no-silent]  [-rURL]  [--repository=URL]
       [--repository-format=FORMAT]     [--root=URL]     [--sftp-delay=SFTP-DELAY]      [--small-files-in-btree]
       [--no-small-files-in-btree] [--ssh-command=EXECUTABLE] [--ssh-host-keys-check=VALUE] [--ssh-key=FILENAME]
       [--ssh-known-hosts=FILENAME]             [--strict-ssh-host-keys]             [--no-strict-ssh-host-keys]
       [--symmetric-key-bits=BITS]        [--testing-fail-matching=REGEXP]       [--to=TO]       [--trace=TRACE]
       [--upload-queue-size=SIZE]    [--verbose]    [--no-verbose]    [--verify-randomly=N]     [--warn-age=AGE]
       [--weak-random] [--no-weak-random]

       obnam [options] _lock
       obnam [options] add-key [CLIENT-NAME]...
       obnam [options] backup [DIRECTORY|URL]...
       obnam [options] client-keys
       obnam [options] clients
       obnam [options] diff [GENERATION1]GENERATION2
       obnam [options] dump-repo
       obnam [options] force-lock
       obnam [options] forget [GENERATION]...
       obnam [options] fsck
       obnam [options] generations
       obnam [options] genids
       obnam [options] help
       obnam [options] help-all
       obnam [options] kdirstat [FILE]...
       obnam [options] list-errors
       obnam [options] list-formats
       obnam [options] list-keys
       obnam [options] list-toplevels
       obnam [options] ls [FILE]...
       obnam [options] mount [ROOT]
       obnam [options] nagios-last-backup-age
       obnam [options] remove-client [CLIENT-NAME]...
       obnam [options] remove-key [CLIENT-NAME]...
       obnam [options] restore [DIRECTORY]...
       obnam [options] verify [DIRECTORY]...

DESCRIPTION

       obnam  makes,  restores,  manipulates, and otherwise deals with backups.  It can store backups on a local
       disk or to a server via sftp.  Every backup generation  looks  like  a  fresh  snapshot,  but  is  really
       incremental:  the  user  does  not need to worry whether it's a full backup or not.  Only changed data is
       backed up, and if a chunk of data is already backed up in another file, that data is re-used.

       The place where backed up data is placed is called the backup  repository.   A  repository  may  be,  for
       example,  a  directory  on  an  sftp  server, or a directory on a USB hard disk.  A single repository may
       contain backups from several clients.  Their data  will  intermingle  as  if  they  were  using  separate
       repositories, but if one client backs up a file, the others may re-use the data.

       obnam  command  line  syntax consists of a command possibly followed by arguments.  The commands are list
       below.

       •      backup makes a new backup.  The first time it is run, it  makes  a  full  backup,  after  that  an
              incremental one.

       •      restore  is  the  opposite  of a backup.  It copies backed up data from the backup repository to a
              target directory.  You can restore everything in a generation, or just selected files.

       •      clients lists the clients that are backed up to the repository.

       •      generations lists every backup generation for  a  given  client,  plus  some  metadata  about  the
              generation.

       •      genids  lists the identifier for every backup generation for a given client.  No other information
              is shown.  This can be useful for scripting.

       •      ls lists the contents of a given generation, similar to ls -lAR.

       •      kdirstat lists the contents of a given generation, in  a  format  which  is  compatible  with  the
              kdirstat cache file format, which can then be used to visualise the contents of a backup.

       •      verify  compares  data in the backup with actual user data, and makes sure they are identical.  It
              is most useful to run immediately after a backup, to check that it actually worked.  It can be run
              at any time, but if the user data has changed, verification fails even though the backup is OK.

       •      forget  removes  backup  generations that are no longer wanted, so that they don't use disk space.
              Note that after a backup generation is removed the data can't be restored anymore.  You can either
              specify the generations to remove by listing them on the command line, or use the --keep option to
              specify a policy for what to keep (everything else will be removed).

       •      fsck checks the internal consistency of the backup repository.   It  verifies  that  all  clients,
              generations,  directories, files, and all file contents still exists in the backup repository.  It
              may take quite a long time to run.

       •      force-lock removes a lock file for a client in the repository.  You should only force  a  lock  if
              you  are  sure  no-one  is  accessing that client's data in the repository.  A dangling lock might
              happen, for example, if obnam loses its network connection to the backup repository.

       •      client-keys lists the encryption key associated with each client.

       •      list-keys lists the keys that can access the repository, and which toplevel directories  each  key
              can access.  Some of the toplevel directories are shared between clients, others are specific to a
              client.

       •      list-toplevels is like list-keys, but lists toplevels and which keys can access them.

       •      add-key adds an encryption key to the repository.  By default, the key is added only to the shared
              toplevel  directories, but it can also be added to specific clients: list the names of the clients
              on the command line.  They key is given with the --keyid option.  Whoever has access to the secret
              key  corresponding  to  the  key  id  can  access the backup repository (the shared toplevels plus
              specified clients).

       •      remove-key removes a key from the shared toplevel directories, plus any clients specified  on  the
              command line.

       •      nagios-last-backup-age  is  a  check  that  exits  with  non-zero return if a backup age exceeds a
              certain threshold.  It is suitable for use as a check plugin for nagios.  Thresholds can be  given
              the --warn-age and --critical-age options.

       •      diff  compares  two  generations and lists files differing between them. Every output line will be
              prefixed either by a plus sign (+) for files that were added, a minus sign (-) for files that have
              been  removed  or  an  asterisk  (*)  for  files  that have changed.  If only one generation ID is
              specified on the command line that generation will be compared with its direct predecessor. If two
              IDs have been specified, all changes between those two generations will be listed.

       •      mount  makes  the  backup  repository  available  via  a  read-only  FUSE filesystem.  Each backup
              generation is visible as a subdirectory, named after the generation id.  This means you  can  look
              at backed up data using normal tools, such as your GUI file manager, or command line tools such as
              ls(1), diff(1), and cp(1).  You can't make new backups with the  mount  subcommand,  but  you  can
              restore data easily.

              You need to have the FUSE utilities and have permission to use FUSE for this to work.  The details
              will vary between operating systems; in Debian, install the package fuse and add yourself  to  the
              fuse group (you may need to log out and back in again).

   Making backups
       When  you  run a backup, obnam uploads data into the backup repository.  The data is divided into chunks,
       and if a chunk already exists in the backup repository, it is not uploaded again.  This allows  obnam  to
       deal  with files that have been changed or renamed since the previous backup run.  It also allows several
       backup clients to avoid uploading the same data.  If, for example, everyone in the office has a  copy  of
       the same sales brochures, only one copy needs to be stored in the backup repository.

       Every  backup  run  is  a  generation.  In addition, obnam will make checkpoint generations every now and
       then.  These are exactly like normal generations, but are not guaranteed to be a complete snapshot of the
       live  data.   If  the backup run needs to be aborted in the middle, the next backup run can continue from
       the latest checkpoint, avoiding the need to start over from scratch.

       If one backup run drops a backup root directory, the  older  generations  will  still  keep  it:  nothing
       changes  in  the old generations just because there is a new one.  If the root was dropped by mistake, it
       can be added back and the next backup run will re-use the existing data in  the  backup  repository,  and
       will only back up the file metadata (filenames, permissions, etc).

   Verifying backups
       What  good  is  a  backup system you cannot rely on?  How can you rely on something you cannot test?  The
       obnam verify command checks that data in the backup repository matches actual user  data.   It  retrieves
       one  or  more files from the repository and compares them to the user data.  This is essentially the same
       as doing a restore, then comparing restored files with the original files using  cmp(1),  but  easier  to
       use.

       By  default, verification happens on all files.  You can also specify the files to be verified by listing
       them on the command line.  You should specify the full paths to the files, not relative  to  the  current
       directory.

       The  output  lists  files that fail verification for some reason.  If you verify everything, it is likely
       that some files (e.g., parent directories of backup root) may have changed without it  being  a  problem.
       Note  that  you  will  need  to  specify  the  whole path to the files or directories to be verified, not
       relative to the backup root.  You still need to specify at least one of the backup roots on  the  command
       line or via the --root option so that obnam will find the filesystem, in case it is a remote one.

   URL syntax
       Whenever  obnam  accepts  a  URL, it can be either a local pathname, or an sftp URL.  An sftp URL has the
       following form:

              sftp://[user@]domain[:port]/path

       where domain is a normal Internet domain name for a server, user is your username on that server, port is
       an optional port number, and path is a pathname on the server side.  Like bzr(1), but unlike the sftp URL
       standard, the pathname is absolute, unless it starts with /~/ in which case it is relative to the  user's
       home directory on the server.

       See the EXAMPLE section for examples of URLs.

       You  can  use  sftp URLs for the repository, or the live data (root), but note that due to limitations in
       the protocol, and its implementation in the paramiko library, some things will not  work  very  well  for
       accessing live data over sftp.  Most importantly, the handling of of hardlinks is rather suboptimal.  For
       live data access, you should not end the URL with /~/ and should append a dot at the end in this  special
       case.

   Generation specifications
       When  not  using  the  latest generation, you will need to specify which one you need.  This will be done
       with the --generation option, which takes a generation specification as its argument.  The  specification
       is  either  the  word  latest,  meaning  the  latest generation (also the default), or a number.  See the
       generations command to see what generations are available, and what their numbers are.

   Policy for keeping and removing backup generations
       The forget command can follow a policy to automatically keep some and remove  other  backup  generations.
       The policy is set with the --keep=POLICY option.

       POLICY  is  comma-separated  list  of  rules.  Each rule consists of a count and a time period.  The time
       periods are h, d, w, m, and y, for hour, day, week, month, and year.

       A policy of 30d means to keep the latest backup for each day when a backup was made, and keep the last 30
       such backups.  Any backup matched by any policy rule is kept, and any backups in between will be removed,
       as will any backups older than the oldest kept backup.

       As an example, assume backups are taken every hour, on the hour: at 00:00, 01:00, 02:00, and so on, until
       23:00.   If  the  forget command is run at 23:15, with the above policy, it will keep the backup taken at
       23:00 on each day, and remove every other backup that day.  It will also remove  backups  older  than  30
       days.

       If  backups are made every other day, at noon, forget would keep the 30 last backups, or 60 days worth of
       backups, with the above policy.

       Note that obnam will only inspect timestamps in the backup repository, and does not care what the  actual
       current  time  is.   This  means  that if you stop making new backups, the existing ones won't be removed
       automatically.  In essence, obnam pretends the current time is just after the latest backup  when  forget
       is run.

       The rules can be given in any order, but will be sorted to ascending order of time period before applied.
       (It is an error to give two rules for the same period.)  A backup generation is kept if  it  matches  any
       rule.

       For  example,  assume  the  same  backup frequency as above, but a policy of 30d,52w.  This will keep the
       newest daily backup for each day for thirty days, and the newest weekly backup for 52 weeks.  Because the
       hourly backups will be removed daily, before they have a chance to get saved by a weekly rule, the effect
       is that the 23:00 o'clock backup for each day is saved for a month, and the 23:00 backup  on  Sundays  is
       saved for a year.

       If,  instead,  you use a policy of 72h,30d,52w, obnam would keep the last 72 hourly backups, and the last
       backup of each calendar day for 30 days, and the last backup of each calendar week for 52 weeks.  If  the
       backup  frequency  was once per day, obnam would keep the backup of each calendar hour for which a backup
       was made, for 72 such backups.  In other words, it would effectively keep the last 72 daily backups.

       Sound confusing?  Just think how confused the developer was when writing the code.

       If no policy is given, forget will keep everything.

       A typical policy might be 72h,7d,5w,12m, which means: keep the last 72 hourly backups, the last  7  daily
       backups,  the  last  5 weekly backups and the last 12 monthly backups.  If the backups are systematically
       run on an hourly basis, this will mean keeping hourly backups for three days, daily backups for  a  week,
       weekly backups for a month, and monthly backups for a year.

       The  way the policy works is a bit complicated.  Run forget with the --pretend option to make sure you're
       removing the right ones.

   Using encryption
       obnam can encrypt all the data it writes to the backup repository.  It uses gpg(1) to do the  encryption.
       You  need to create a key pair using gpg --gen-key (or use an existing one), and then tell obnam about it
       using the --encrypt-with option.  You may optionally use a separate home directory using the  --gnupghome
       option. By default, the default directory for gpg(1) will be used.

   Configuration files
       obnam will look for configuration files in a number of locations.  See the FILES section for a list.  All
       these files together are treated as one big file with the contents of all files concatenated.

       The files are in INI format, and only the [config] section is used (any other sections are ignored).

       The long names of options are used as keys for configuration variables.  Any setting that can be set from
       the command line can be set in a configuration file, in the [config] section.

       For example, the options in the following command line:

              obnam --repository=/backup --exclude='.wav$' backup

       could be replaced with the following configuration file:

              [config]
              repository: /backup
              exclude: .wav$

       (You can use either foo=value or foo: value syntax in the files.)

       The only unusual thing about the files is the way options that can be used many times are expressed.  All
       values are put in a single logical line, separated by  commas  (and  optionally  spaces  as  well).   For
       example:

              [config]
              exclude = foo, bar, \.mp3$

       The  above  has three values for the exclude option: any files that contain the words foo or bar anywhere
       in the fully qualified pathname, or files with names ending with a period and mp3 (because the exclusions
       are regular expressions).

       A  long logical line can be broken into several physical ones, by starting a new line at white space, and
       indenting the continuation lines:

              [config]
              exclude = foo,
                  bar,
                  \.mp3$

       The above example adds three exclusion patterns.

   Multiple clients and locking
       obnam supports sharing a repository between multiple clients.  The clients can share  the  file  contents
       (chunks), so that if client A backs up a large file, and client B has the same file, then B does not need
       to upload the large file to the repository a second time.   For  this  to  work  without  confusion,  the
       clients  use  a  simple  locking protocol that allows only one client at a time to modify the shared data
       structures.  Locks do not prevent read-only access at the same time: this allows  you  to  restore  while
       someone else is backing up.

       Sometimes  a  read-only  operation  happens  to  access  a data structure at the same time as it is being
       modified.  This can result in a crash.  It will not  result  in  corrupt  data,  or  incorrect  restores.
       However, you may need to restart the read-only operation after a crash.

OPTIONS

       --always-restore-setuid
              restore  setuid/setgid  bits  in  restored files, even if not root or backed up file had different
              owner than user running restore

       --no-always-restore-setuid
              opposite of --always-restore-setuid

       --client-name=CLIENT-NAME
              name of client (defaults to hostname)

       --compress-with=PROGRAM
              use PROGRAM to compress repository with (one of none, deflate)

       --critical-age=AGE
              for nagios-last-backup-age: maximum age (by default in hours) for the most  recent  backup  before
              statis  is  critical.  Accepts  one  char unit specifier (s,m,h,d for seconds, minutes, hours, and
              days.

       --dump-repo-file-metadata
              dump metadata about files?

       --no-dump-repo-file-metadata
              opposite of --dump-repo-file-metadata

       --generate-manpage=TEMPLATE
              SUPPRESSHELP

       --generation=GENERATION
              which generation to restore

       -h, --help
              show this help message and exit

       --keep=KEEP
              policy for what generations to keep when forgetting

       --lock-timeout=TIMEOUT
              when locking in the backup repository, wait TIMEOUT seconds for an existing lock to go away before
              giving up

       --output=FILE
              write output to FILE, instead of standard output

       --pretend, --dry-run, --no-act
              do not actually change anything (works with backup, forget and restore only, and may only simulate
              approximately real behavior)

       --no-pretend, --no-dry-run, --no-no-act
              opposite of --pretend

       --quiet, --silent
              be silent: show only error messages, no progress updates

       --no-quiet, --no-silent
              opposite of --quiet

       -r, --repository=URL
              name of backup repository (can be pathname or supported URL)

       --repository-format=FORMAT
              use FORMAT for new repositories; one of "6", "green-albatross"

       --to=TO
              where to restore or FUSE mount; for restores, must be empty or must not exist

       --verbose
              be verbose: tell the user more of what is going on and generally make sure the user  is  aware  of
              what  is  happening  or  at  least  that something is happening and also make sure their screen is
              getting updates frequently and that there is changes happening all the time so  they  do  not  get
              bored and that they in fact get frustrated by getting distracted by so many updates that they will
              move into the Gobi desert to live under a rock

       --no-verbose
              opposite of --verbose

       --verify-randomly=N
              verify N files randomly from the backup (default is zero, meaning everything)

       --version
              show program's version number and exit

       --warn-age=AGE
              for nagios-last-backup-age: maximum age (by default in hours) for the most  recent  backup  before
              status is warning. Accepts one char unit specifier (s,m,h,d for seconds, minutes, hours, and days.

   Backing up
       --checkpoint=SIZE
              make a checkpoint after a given SIZE

       --deduplicate=MODE
              find duplicate data in backed up data and store it only once; three modes are available: never de-
              duplicate, verify that no hash collisions happen, or (the default) fatalistically accept the  risk
              of collisions

       --exclude=EXCLUDE
              regular expression for pathnames to exclude from backup (can be used multiple times)

       --exclude-caches
              exclude    directories   (and   their   subdirs)   that   contain   a   CACHEDIR.TAG   file   (see
              http://www.brynosaurus.com/cachedir/spec.html   for   what    it    needs    to    contain,    and
              http://liw.fi/cachedir/ for a helper tool)

       --no-exclude-caches
              opposite of --exclude-caches

       --exclude-from=FILE
              read exclude patterns from FILE

       --include=INCLUDE
              regular expression for pathnames to include from backup even if it matches an exclude rule (can be
              used multiple times)

       --leave-checkpoints
              leave checkpoint generations at the end of a successful backup run

       --no-leave-checkpoints
              opposite of --leave-checkpoints

       --one-file-system
              exclude directories (and their subdirs) that are in a different filesystem

       --no-one-file-system
              opposite of --one-file-system

       --root=URL
              what to backup

       --small-files-in-btree
              this is available only for backwards compatibility; do  not  use  it,  and  remove  it  from  your
              configuration

       --no-small-files-in-btree
              opposite of --small-files-in-btree

   Configuration files and settings
       --config=FILE
              add FILE to config files

       --dump-config
              write out the entire current configuration

       --dump-setting-names
              SUPPRESSHELP

       --help-all
              show all options

       --list-config-files
              SUPPRESSHELP

       --no-default-configs
              clear list of configuration files to read

   Development of Obnam itself
       --crash-limit=COUNTER
              artificially  crash  the program after COUNTER files written to the repository; this is useful for
              crash testing the application, and should not be enabled  for  real  use;  set  to  0  to  disable
              (disabled by default)

       --pretend-time=TIMESTAMP
              pretend it is TIMESTAMP (YYYY-MM-DD HH:MM:SS); this is only useful for testing purposes

       --sftp-delay=SFTP-DELAY
              add an artificial delay (in milliseconds) to all SFTP transfers

       --testing-fail-matching=REGEXP
              development testing helper: simulate failures during backup for files that match the given regular
              expressions

       --trace=TRACE
              add to filename patters for which trace debugging logging happens

   Encryption
       --encrypt-with=ENCRYPT-WITH
              PGP key with which to encrypt data in the backup repository

       --gnupghome=HOMEDIR
              home directory for GPG

       --key-details
              show additional user IDs for all keys

       --no-key-details
              opposite of --key-details

       --keyid=KEYID
              PGP key id to add to/remove from the backup repository

       --symmetric-key-bits=BITS
              size of symmetric key, in bits

       --weak-random
              use /dev/urandom instead of /dev/random to generate symmetric keys

       --no-weak-random
              opposite of --weak-random

   Integrity checking (fsck)
       --fsck-fix
              should fsck try to fix problems? Implies --fsck-rm-unused

       --no-fsck-fix
              opposite of --fsck-fix

       --fsck-ignore-chunks
              ignore chunks when checking repository integrity (assume all chunks exist and are correct)

       --no-fsck-ignore-chunks
              opposite of --fsck-ignore-chunks

       --fsck-ignore-client=NAME
              do not check repository data for cient NAME

       --fsck-last-generation-only
              check only the last generation for each client

       --no-fsck-last-generation-only
              opposite of --fsck-last-generation-only

       --fsck-rm-unused
              should fsck remove unused chunks?

       --no-fsck-rm-unused
              opposite of --fsck-rm-unused

       --fsck-skip-checksums
              do not check checksums of files

       --no-fsck-skip-checksums
              opposite of --fsck-skip-checksums

       --fsck-skip-dirs
              do not check anything about directories and their files

       --no-fsck-skip-dirs
              opposite of --fsck-skip-dirs

       --fsck-skip-files
              do not check anything about files

       --no-fsck-skip-files
              opposite of --fsck-skip-files

       --fsck-skip-generations
              do not check any generations

       --no-fsck-skip-generations
              opposite of --fsck-skip-generations

       --fsck-skip-per-client-b-trees
              do not check per-client B-trees

       --no-fsck-skip-per-client-b-trees
              opposite of --fsck-skip-per-client-b-trees

       --fsck-skip-shared-b-trees
              do not check shared B-trees

       --no-fsck-skip-shared-b-trees
              opposite of --fsck-skip-shared-b-trees

   Logging
       --log=FILE
              write log entries to FILE (default is to not write log files at  all);  use  "syslog"  to  log  to
              system log, "stderr" to log to the standard error output, or "none" to disable logging

       --log-keep=N
              keep last N logs (10)

       --log-level=LEVEL
              log at LEVEL, one of debug, info, warning, error, critical, fatal (default: info)

       --log-max=SIZE
              rotate logs larger than SIZE, zero for never (default: 0)

       --log-mode=MODE
              set permissions of new log files to MODE (octal; default 0600)

   Mounting with FUSE
       --fuse-opt=FUSE
              options to pass directly to Fuse

   Peformance
       --dump-memory-profile=METHOD
              make  memory  profiling  dumps  using  METHOD,  which is one of: none, simple, or meliae (default:
              simple)

       --memory-dump-interval=SECONDS
              make memory profiling dumps at least SECONDS apart

   Performance tweaking
       --chunk-size=SIZE
              size of chunks of file data backed up

       --chunkids-per-group=NUM
              encode NUM chunk ids per group

       --idpath-bits=IDPATH-BITS
              chunk id level size

       --idpath-depth=IDPATH-DEPTH
              depth of chunk id mapping

       --idpath-skip=IDPATH-SKIP
              chunk id mapping lowest bits skip

       --lru-size=SIZE
              size of LRU cache for B-tree nodes

       --node-size=SIZE
              size of B-tree nodes on disk; only affects new B-trees so you may  need  to  delete  a  client  or
              repository to change this for existing repositories

       --upload-queue-size=SIZE
              length of upload queue for B-tree nodes

   Repository format green-albatross
       --chunk-bag-size=SIZE
              approximate maximum size of bag combining many chunk objects

       --chunk-cache-size=SIZE
              size of in-memory cache for file data chunk objects

       --dir-bag-size=SIZE
              approximage maximum size of bags combining many DIR objects

       --dir-cache-size=SIZE
              size of in-memory cache for DIR objects

   SSH/SFTP
       --pure-paramiko
              do not use openssh even if available, use paramiko only instead

       --no-pure-paramiko
              opposite of --pure-paramiko

       --ssh-command=EXECUTABLE
              alternative  executable  to  be  used  instead of "ssh" (full path is allowed, no arguments may be
              added)

       --ssh-host-keys-check=VALUE
              If "yes", require that the ssh host key must be known and correct to be accepted. If "no", do  not
              require  that.  If  "ask", the user is interactively asked to accept new hosts. The default ("ssh-
              config") is to rely on the settings of the underlying SSH client

       --ssh-key=FILENAME
              use FILENAME as the ssh RSA private key for sftp access (default is using keys known to ssh-agent)

       --ssh-known-hosts=FILENAME
              filename of the user's known hosts file

       --strict-ssh-host-keys
              DEPRECATED, use --ssh-host-keys-check instead

       --no-strict-ssh-host-keys
              opposite of --strict-ssh-host-keys

   Option values
       The SIZE value in options mentioned above specifies a size in bytes, with optional suffixes  to  indicate
       kilobytes  (k),  kibibytes  (Ki),  megabytes (M), mebibyts (Mi), gigabytes (G), gibibytes (Gi), terabytes
       (T), tibibytes (Ti).  The suffixes are case-insensitive.

EXIT STATUS

       obnam will exit with zero if everything went well, and non-zero otherwise.

ENVIRONMENT

       obnam will pass on the environment it gets from its parent, without modification.  It does not  obey  any
       unusual  environment  variables, but it does obey the usual ones when running external programs, creating
       temporary files, etc.

FILES

       /etc/obnam.conf
       /etc/obnam/*.conf
       ~/.obnam.conf
       ~/.config/obnam/*.conf
              Configuration files for obnam.  It is not an error for any or all of the files to not exist.

EXAMPLE

       To back up your home directory to a server:

              obnam backup --repository sftp://your.server/~/backups $HOME

       To restore your latest backup from the server:

              obnam restore --repository sftp://your.server/~/backups \
              --to /var/tmp/my.home.dir

       To restore just one file or directory:

              obnam restore --repository sftp://your.server/~/backups \
              --to /var/tmp/my.home.dir $HOME/myfile.txt

       Alternatively, mount the backup repository using the FUSE  filesystem  (note  that  the  --to  option  is
       necessary):

              mkdir my-repo
              obnam mount --repository sftp://your.server/~/backups \
              --to my-repo
              cp my-repo/latest/$HOME/myfile.txt
              fusermount -u my-repo

       To check that the backup worked:

              obnam verify --repository sftp://your.server/~/backups \
              /path/to/file

       To remove old backups, keeping the newest backup for each day for
       ten years:

              obnam forget --repository sftp://your.server/~/backups \
              --keep 3650d

       To verify that the backup repository is OK:

              obnam fsck --repository sftp://your.server/~/backups

       To view the backed up files in the backup repository using FUSE:

              obnam mount --to my-fuse
              ls -lh my-fuse
              fusermount -u my-fuse

SEE ALSO

       obnam  comes  with  a manual in HTML and PDF forms.  See /usr/share/doc/obnam if you have Obnam installed
       system-wide, or in the subdirectory manual in the source tree.

       cliapp(5)

                                                                                                        OBNAM(1)