pdf viewer in asp net c# : Adding images to pdf control SDK platform web page wpf windows web browser postgresql-9.4-A464-part2988

Chapter 24. Backup and Restore
up each database in a given cluster, and also preserves cluster-wide data such as role and tablespace
definitions. The basic usage of this command is:
pg_dumpall >
outfile
The resulting dump can be restoredwith psql:
psql -f
infile
postgres
(Actually, you can specify any existing database name to start from, but if you are loading into an
empty cluster then
postgres
should usually be used.) It is always necessary to have database supe-
ruser access when restoring a pg_dumpall dump, as that is required to restore the role and tablespace
information. If you use tablespaces, make sure that the tablespace paths in the dump are appropriate
for the new installation.
pg_dumpall works by emitting commands to re-create roles, tablespaces, and empty databases, then
invoking pg_dump for each database. This means that while each database will be internally consis-
tent, the snapshots of different databases are not sychronized.
Cluster-wide data can be dumpedalone usingthe pg_dumpall
--globals-only
option. This is nec-
essary to fully backup the cluster if running the pg_dump command on individual databases.
24.1.3. Handling Large Databases
Some operating systems have maximum file size limits that cause problems when creating large
pg_dump output files. Fortunately, pg_dump can writeto the standard output, so you canuse standard
Unix tools to work around this potential problem. There are several possible methods:
Use compressed dumps. You can use your favorite compression program, for example gzip:
pg_dump
dbname
| gzip >
filename
.gz
Reload with:
gunzip -c
filename
.gz | psql
dbname
or:
cat
filename
.gz | gunzip | psql
dbname
Use
split
.The
split
command allows you to split the output into smaller files that are acceptable
in size to the underlying file system. For example, to make chunks of 1 megabyte:
pg_dump
dbname
| split -b 1m -
filename
Reload with:
cat
filename*
| psql
dbname
Use pg_dump’s custom dump format. If PostgreSQL was built on a system with the zlib compres-
sion library installed, thecustom dump format will compress dataas it writes it to the outputfile. This
will produce dump file sizes similar to using
gzip
,but it has the added advantage that tables can be
restored selectively. The following command dumps a database using the custom dump format:
pg_dump -Fc
dbname
>
filename
568
Adding images to pdf - insert images into PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sample C# code to add image, picture, logo or digital photo into PDF document page using PDF page editor control
add image to pdf preview; adding an image to a pdf in acrobat
Adding images to pdf - VB.NET PDF insert image library: insert images into PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide VB.NET Programmers How to Add Images in PDF Document
adding image to pdf; add a picture to a pdf file
Chapter 24. Backup and Restore
Acustom-format dump is not a script for psql, but instead must be restored with pg_restore, for
example:
pg_restore -d
dbname filename
See the pg_dump andpg_restore reference pages for details.
For very large databases, you might need to combine
split
with one of the other two approaches.
Use pg_dump’s parallel dump feature. To speed up the dump of a large database, you can use
pg_dump’s parallel mode. This will dump multiple tables at the same time. Youcancontrol the degree
of parallelism with the
-j
parameter. Parallel dumps are only supported for the "directory" archive
format.
pg_dump -j
num
-F d -f
out.dir dbname
You can use
pg_restore -j
to restore a dump in parallel. This will work for any archive of either
the "custom" or the "directory" archive mode, whether or not it has been created with
pg_dump -j
.
24.2. File System Level Backup
An alternative backup strategy is to directly copy the files that PostgreSQL uses to store the data in
the database; Section 17.2 explains where these files are located. You can use whatever method you
prefer for doing file system backups; for example:
tar -cf backup.tar /usr/local/pgsql/data
There are two restrictions, however, which make this method impractical, or at least inferior to the
pg_dump method:
1. The database server must be shut down in order to get a usable backup. Half-way measures such
as disallowing allconnections will not work (in part because
tar
andsimilar tools do not take an
atomic snapshot of the state of the file system, but also because of internal buffering within the
server). Information about stopping the server can be found inSection17.5. Needless to say, you
also need to shut down the server before restoring the data.
2. If you have dug into the details of the file system layout of the database, you might be tempted
to try to back up or restore only certain individual tables or databases from their respective files
or directories. This will not work because the information contained in these files is not usable
without the commit log files,
pg_clog/
*
,which contain the commit status of all transactions.
Atable file is only usable with this information. Of course it is also impossible to restore only a
table and the associated
pg_clog
data because that would render all other tables in the database
cluster useless. So file system backupsonly work for completebackupandrestoration of an entire
database cluster.
An alternative file-system backup approach is to make a “consistent snapshot” of the data directory, if
thefile system supports thatfunctionality (andyouarewillingtotrustthatitis implementedcorrectly).
The typical procedureis tomakea “frozensnapshot”of thevolumecontainingthedatabase, thencopy
the whole data directory (notjust parts, see above) from the snapshot to a backupdevice, then release
the frozen snapshot. This will work even while the database server is running. However, a backup
569
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Feel free to define text or images on PDF document and extract accordingly. Capable of adding PDF file navigation features to your VB.NET program.
add image to pdf in preview; add picture to pdf reader
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
Support adding PDF page number. Offer PDF page break inserting function. DLLs for Adding Page into PDF Document in VB.NET Class. Add necessary references:
add image to pdf form; adding images to a pdf document
Chapter 24. Backup and Restore
created in this way saves the database files in a state as if the database server was not properly shut
down; therefore, when you start the database server on the backed-up data, it will think the previous
server instance crashed and will replay the WAL log. This is not a problem; just be aware of it (and
be sure to include the WAL files in your backup). You can perform a
CHECKPOINT
before taking the
snapshot to reduce recovery time.
If your database is spread across multiple file systems, there might not be any way to obtain exactly-
simultaneous frozen snapshots of all the volumes. For example, if your data files and WAL log are
on different disks, or if tablespaces are on different file systems, it might not be possible to use
snapshot backup because the snapshots must be simultaneous. Read your file system documentation
very carefully before trusting the consistent-snapshot technique in such situations.
If simultaneous snapshots arenotpossible, one optionis toshutdownthe database server longenough
to establishall the frozen snapshots. Another option is toperform a continuous archiving base backup
(Section 24.3.2) because such backups are immune to file system changes during the backup. This re-
quires enabling continuous archiving just during the backupprocess; restore is done using continuous
archive recovery (Section 24.3.4).
Another option is to use rsync to perform a file system backup. This is done by first running rsync
while the database server is running, then shutting down the database server just long enough to do a
secondrsync. The second rsync will be much quicker thanthe first, because it has relatively little data
to transfer, and the end result will be consistent because the server was down. This method allows a
file system backup to be performed with minimal downtime.
Note that a file system backup will typically be larger than an SQL dump. (pg_dump does not need
to dumpthe contents of indexes for example, just the commands torecreate them.) However, taking a
file system backup might be faster.
24.3. Continuous Archiving and Point-in-Time
Recovery (PITR)
At all times, PostgreSQL maintains a write ahead log (WAL) in the
pg_xlog/
subdirectory of the
cluster’s data directory. The log records every change made tothedatabase’s data files. This log exists
primarily for crash-safety purposes: if the system crashes, the database can be restored toconsistency
by “replaying”thelogentries made since the last checkpoint. However, theexistence of thelogmakes
it possible touse a third strategy for backing updatabases: we cancombine a file-system-level backup
with backupof the WAL files. If recovery is needed, we restore the file system backup andthen replay
from the backed-up WAL files to bring the system to a current state. This approach is more complex
to administer than either of the previous approaches, but it has some significant benefits:
We do not need a perfectly consistent file system backup as the starting point. Any internal incon-
sistency in the backup will be corrected by log replay (this is not significantly different from what
happens during crash recovery). So we do not need a file system snapshot capability, just tar or a
similar archiving tool.
Since we can combine an indefinitely long sequence of WAL files for replay, continuous backup
can be achieved simply by continuing to archive the WAL files. This is particularly valuable for
large databases, where it might not be convenient to take a full backup frequently.
It is not necessary to replay the WAL entries all the way to the end. We could stop the replay at
any point and have a consistent snapshot of the database as it was at that time. Thus, this technique
570
C# PDF Page Insert Library: insert pages into PDF file in C#.net
By using reliable APIs, C# programmers are capable of adding and inserting (empty) PDF page or pages from various file formats, such as PDF, Tiff, Word, Excel
how to add a jpeg to a pdf; how to add image to pdf document
C# PDF insert text Library: insert text into PDF content in C#.net
Supports adding text to PDF in preview without adobe reader installed in ASP.NET. Powerful .NET PDF edit control allows modify existing scanned PDF text.
add a picture to a pdf; how to add image to pdf
Chapter 24. Backup and Restore
supports point-in-time recovery: it is possible to restore the database to its state at any time since
your base backup was taken.
If we continuously feed the series of WAL files to another machine that has been loaded with the
same base backup file, we have a warm standby system: at any point we can bring up the second
machine and it will have a nearly-current copy of the database.
Note: pg_dump and pg_dumpall do not produce file-system-level backups and cannot be used
as part of a continuous-archiving solution. Such dumps are logical and do not contain enough
information to be used by WAL replay.
As with the plain file-system-backup technique, this method can only support restoration of an entire
database cluster, not a subset. Also, it requires a lot of archival storage: the base backup might be
bulky, and a busy system will generate many megabytes of WAL traffic that have tobe archived. Still,
it is the preferred backup technique in many situations where high reliability is needed.
To recover successfully using continuous archiving (also called “online backup” by many database
vendors), youneeda continuous sequenceof archivedWAL files that extends back atleastas far as the
start time of your backup. So to get started, you should set up and test your procedure for archiving
WAL files before you take your first base backup. Accordingly, we first discuss the mechanics of
archiving WAL files.
24.3.1. Setting Up WAL Archiving
In an abstract sense, a running PostgreSQL system produces an indefinitely long sequence of WAL
records. The system physically divides this sequence into WAL segment files, which are normally
16MB apiece (although the segment size can be altered when building PostgreSQL). The segment
files are given numeric names that reflect their position in the abstract WAL sequence. When not
using WAL archiving, the system normally creates just a few segment files and then “recycles” them
by renaming no-longer-needed segment files to higher segment numbers. It’s assumed that segment
files whose contents precede the checkpoint-before-last are no longer of interest and can be recycled.
When archiving WAL data, we need to capture the contents of each segment file once it is filled, and
save that data somewhere before the segment file is recycled for reuse. Depending on the application
and the available hardware, there could be many different ways of “saving the data somewhere”: we
could copy the segment files to an NFS-mounted directory on another machine, write them onto a
tape drive (ensuring that you have a way of identifying the original name of each file), or batch them
together and burn them onto CDs, or something else entirely. To provide the database administrator
with flexibility, PostgreSQL tries not to make any assumptions about how the archiving will be done.
Instead, PostgreSQL lets the administrator specify a shell command to be executed to copy a com-
pleted segment file to wherever it needs to go. The command could be as simple as a
cp
,or it could
invoke a complex shell script — it’s all up to you.
To enable WAL archiving, set the wal_level configuration parameter to
archive
or higher,
archive_mode to
on
,and specify the shell command to use in the archive_command configuration
parameter. In practice these settings will always be placed in the
postgresql.conf
file. In
archive_command
,
%p
is replaced by the path name of the file to archive, while
%f
is replaced by
only the file name. (The path name is relative to the current working directory, i.e., the cluster’s data
directory.) Use
%%
if you need to embed an actual
%
character in the command. The simplest useful
command is something like:
571
VB.NET Image: How to Draw Annotation on Doc Images with Image SDK
to mark and annotate your local images (such as page TIFF, Microsoft Office Word and PDF file other image annotating tutorials besides adding annotation using VB
add jpg to pdf acrobat; add an image to a pdf form
VB.NET Image: Adding Line Annotation to Images with VB.NET Doc
NET full sample codes for printing line annotation on images. VB.NET Image Line Annotation Overview. Mature image processing library for adding line annotation
add photo to pdf online; how to add an image to a pdf in preview
Chapter 24. Backup and Restore
archive_command = ’test ! -f /mnt/server/archivedir/%f && cp %p /mnt/server/archivedir/%f’
archive_command = ’copy "%p" "C:\\server\\archivedir\\%f"’
# Windows
which will copy archivable WAL segments to the directory
/mnt/server/archivedir
.(This is an
example, not arecommendation, andmightnot workonallplatforms.) After the
%p
and
%f
parameters
have been replaced, the actual command executed might look like this:
test ! -f /mnt/server/archivedir/00000001000000A900000065 && cp pg_xlog/00000001000000A900000065 /mnt/server/archivedir/00000001000000A900000065
Asimilar command will be generated for each new file to be archived.
The archive command will be executed under the ownership of the same user that the PostgreSQL
server is running as. Since the series of WAL files being archived contains effectively everything
in your database, you will want to be sure that the archived data is protected from prying eyes; for
example, archive into a directory that does not have group or world read access.
Itis important that the archive commandreturn zero exitstatus if and onlyif itsucceeds. Upongetting
azeroresult, PostgreSQL will assume thatthe file has been successfully archived, and willremove or
recycle it. However, a nonzero status tells PostgreSQL that the file was not archived; it will try again
periodically until it succeeds.
The archive command should generally be designed to refuse to overwrite any pre-existing archive
file. This is animportant safetyfeaturetopreserve the integrityof your archiveincase of administrator
error (such as sending the output of two different servers to the same archive directory).
It is advisable to test your proposed archive command to ensure that it indeed does not overwrite an
existing file, and that it returns nonzero status in this case. The example command above for Unix
ensures this by including a separate
test
step. On some Unix platforms,
cp
has switches such as
-i
thatcanbe used to dothe same thingless verbosely, butyou should not relyonthesewithout verifying
that the right exit status is returned. (In particular, GNU
cp
will return status zero when
-i
is used
and the target file alreadyexists, which is not the desired behavior.)
While designingyour archivingsetup, consider what will happenif the archive command fails repeat-
edlybecause some aspect requires operator interventionor thearchive runs outof space. For example,
this could occur if you write to tape without an autochanger; when the tape fills, nothing further can
be archived until the tape is swapped. You should ensure that any error condition or request to a hu-
man operator is reported appropriately so that the situation can be resolved reasonably quickly. The
pg_xlog/
directory will continue to fill with WAL segment files until the situation is resolved. (If
the file system containing
pg_xlog/
fills up, PostgreSQL will do a PANIC shutdown. No committed
transactions will be lost, but the database will remain offline until you free some space.)
The speed of the archiving command is unimportant as long as it can keep up with the average rate
at which your server generates WAL data. Normal operation continues even if the archiving process
falls a little behind. If archiving falls significantly behind, this will increase the amount of data that
would be lost in the event of a disaster. It will also mean that the
pg_xlog/
directory will contain
large numbers of not-yet-archived segment files, which could eventually exceed available disk space.
You are advised to monitor the archiving process to ensure that it is working as you intend.
In writing your archive command, you should assume that the file names to be archived can be up
to 64 characters long and can contain any combination of ASCII letters, digits, and dots. It is not
necessary to preserve the original relative path (
%p
)but it is necessary to preserve the file name (
%f
).
Note that although WAL archiving will allow you to restore any modifications made to the data
in your PostgreSQL database, it will not restore changes made to configuration files (that is,
postgresql.conf
,
pg_hba.conf
and
pg_ident.conf
), since those are edited manually rather
than through SQL operations. You might wish to keep the configuration files in a location that will
572
C# PDF Library SDK to view, edit, convert, process PDF file for C#
Support protecting PDF file by adding password and digital signatures with C# sample code in .NET Class. Feel free to define text or images on PDF document and
add image to pdf reader; how to add a photo to a pdf document
VB.NET PDF insert text library: insert text into PDF content in vb
VB.NET PDF - Insert Text to PDF Document in VB.NET. Providing Demo Code for Adding and Inserting Text to PDF File Page in VB.NET Program.
add picture to pdf in preview; attach image to pdf form
Chapter 24. Backup and Restore
be backed up by your regular file system backup procedures. See Section 18.2 for how to relocate the
configuration files.
The archive command is only invoked on completed WAL segments. Hence, if your server generates
only little WAL traffic(or has slack periods whereit does so), there could be a long delay between the
completion of a transaction and its safe recording in archive storage. To put a limit on how old unar-
chived data can be, you can set archive_timeout to force the server to switch to a new WAL segment
file at least that often. Note thatarchived files thatarearchivedearly due toa forcedswitchare still the
same length as completely full files. Itis therefore unwise to seta very short
archive_timeout
—it
will bloat your archive storage.
archive_timeout
settings of a minute or so are usually reasonable.
Also, you can force a segment switch manually with
pg_switch_xlog
if you want to ensure that
ajust-finished transaction is archived as soon as possible. Other utility functions related to WAL
management are listed in Table 9-65.
When
wal_level
is
minimal
some SQL commands are optimized to avoid WAL logging, as de-
scribed in Section 14.4.7. If archiving or streaming replication were turned on during execution of
one of these statements, WAL would not contain enough information for archive recovery. (Crash
recovery is unaffected.) For this reason,
wal_level
can only be changed at server start. However,
archive_command
can be changed with a configuration file reload. If you wish to temporarily stop
archiving, one way to do it is to set
archive_command
tothe empty string (
). This will cause WAL
files to accumulate in
pg_xlog/
until a working
archive_command
is re-established.
24.3.2. Making a Base Backup
The easiest way to perform a base backup is to use the pg_basebackup tool. It can create a base
backup either as regular files or as a tar archive. If more flexibility than pg_basebackup can provide
is required, you canalso make a base backup using the low level API (see Section 24.3.3).
It is notnecessary tobe concernedabout the amount of time it takes to make a base backup. However,
if you normally run the server with
full_page_writes
disabled, you might notice a drop in per-
formance while the backup runs since
full_page_writes
is effectively forced on during backup
mode.
To make use of the backup, you will need to keep all the WAL segment files generated during
and after the file system backup. To aid you in doing this, the base backup process creates a
backup history file that is immediately stored into the WAL archive area. This file is named after
the first WAL segment file that you need for the file system backup. For example, if the starting
WAL file is
0000000100001234000055CD
the backup history file will be named something like
0000000100001234000055CD.007C9330.backup
. (The second part of the file name stands
for an exact position within the WAL file, and can ordinarily be ignored.) Once you have safely
archived the file system backup and the WAL segment files used during the backup (as specified in
the backup history file), all archived WAL segments with names numerically less are no longer
needed to recover the file system backup and can be deleted. However, you should consider keeping
several backupsets to be absolutely certain that you can recover your data.
The backup history file is just a small textfile. It contains the label string you gaveto pg_basebackup,
as well as the starting and ending times and WAL segments of the backup. If you used the label to
identify the associated dump file, then the archived history file is enough to tell you which dump file
to restore.
Since you have to keep around all the archived WAL files back to your last base backup, the interval
between base backups should usually be chosen based on how much storage you want to expend
on archived WAL files. You should also consider how long you are prepared to spend recovering, if
573
C# PDF Annotate Library: Draw, edit PDF annotation, markups in C#.
Provide users with examples for adding text box to PDF and edit font size and color in text box field in C#.NET program. C#.NET: Draw Markups on PDF File.
add a jpg to a pdf; add jpg to pdf
Chapter 24. Backup and Restore
recovery should be necessary — the system will have to replay all those WAL segments, and that
could take awhile if it has been a long time since the last base backup.
24.3.3. Making a Base Backup Using the Low Level API
The procedure for making a base backup using the low level APIs contains a few more steps than the
pg_basebackup method, but is relatively simple. It is very important that these steps are executed in
sequence, and that the success of a step is verified before proceeding to the next step.
1. Ensure that WAL archiving is enabled and working.
2. Connect to the database as a superuser and issue the command:
SELECT pg_start_backup(’label’);
where
label
is any string you want touse to uniquely identify this backupoperation. (One good
practice is touse the full path where you intend to put the backup dump file.)
pg_start_backup
creates a backup labelfile, called
backup_label
,inthecluster directory withinformation about
your backup, including the start time and label string. The file is critical to the integrity of the
backup, should you need to restore from it.
It does not matter which database within the cluster you connect to to issue this command. You
can ignore the result returned by the function; but if it reports an error, deal with that before
proceeding.
By default,
pg_start_backup
can take a long time to finish. This is because it performs a
checkpoint, and the I/O required for the checkpoint will be spread out over a significant period
of time, by default half your inter-checkpoint interval (see the configuration parameter check-
point_completion_target). This is usually what you want, because it minimizes the impact on
query processing. If you want to start the backup as soon as possible, use:
SELECT pg_start_backup(’label’, true);
This forces the checkpoint to be done as quickly as possible.
3. Perform the backup, using any convenient file-system-backup tool such as tar or cpio (not
pg_dump or pg_dumpall). It is neither necessary nor desirable to stop normal operation of the
database while you do this.
4. Again connect to the database as a superuser, and issue the command:
SELECT pg_stop_backup();
This terminates the backup mode and performs an automatic switch to the next WAL segment.
The reason for the switch is to arrange for the last WAL segment file written during the backup
interval to be ready to archive.
5. Once the WAL segment files active during the backup are archived, you are done. The file iden-
tified by
pg_stop_backup
’s result is the last segment that is required to form a complete set of
backup files. If
archive_mode
is enabled,
pg_stop_backup
does not return until the last seg-
ment has been archived. Archiving of these files happens automatically since you have already
configured
archive_command
.In most cases this happens quickly, but you are advisedto mon-
itor your archive system to ensure there are no delays. If the archive process has fallen behind
because of failures of the archive command, it will keep retrying until the archive succeeds and
the backup is complete. If you wish to place a time limit on the execution of
pg_stop_backup
,
set an appropriate
statement_timeout
value.
574
Chapter 24. Backup and Restore
Some file system backup tools emit warnings or errors if the files theyaretryingtocopy change while
the copy proceeds. When taking a base backup of an active database, this situation is normal and
not an error. However, you need to ensure that you can distinguish complaints of this sort from real
errors. For example, some versions of rsync return a separate exit code for “vanished source files”,
and you can write a driver script to accept this exit code as a non-error case. Also, some versions
of GNU tar return an error code indistinguishable from a fatal error if a file was truncated while
tar was copying it. Fortunately, GNU tar versions 1.16 and later exit with 1 if a file was changed
during the backup, and 2 for other errors. With GNU tar version 1.23 and later, you can use the warn-
ing options
--warning=no-file-changed --warning=no-file-removed
to hide the related
warning messages.
Be certain that your backup dump includes all of the files under the database cluster directory (e.g.,
/usr/local/pgsql/data
). If you are usingtablespaces thatdonot reside underneath this directory,
be carefultoinclude them aswell(andbesure thatyour backupdumparchives symbolic linksas links,
otherwise the restore will corrupt your tablespaces).
You can, however, omit from the backup dump the files within the cluster’s
pg_xlog/
subdirectory.
This slight adjustment is worthwhile because it reduces the risk of mistakes when restoring. This
is easy to arrange if
pg_xlog/
is a symbolic link pointing to someplace outside the cluster direc-
tory, which is a common setup anyway for performance reasons. You might also want to exclude
postmaster.pid
and
postmaster.opts
,which record information about the running postmaster,
not about the postmaster which will eventually use this backup. (These files can confuse pg_ctl.)
Itis oftena goodideatoalso omit from the backup dump the files within the cluster’s
pg_replslot/
directory, sothatreplication slots thatexistonthemaster donotbecomepart of the backup. Otherwise,
the subsequentuse of the backup to createa standbymayresult in indefinite retentionof WAL files on
the standby, and possibly bloat on the master if hot standby feedback is enabled, because the clients
that are using those replication slots will still be connecting to and updating the slots on the master,
not the standby. Even if the backup is only intended for use in creating a new master, copying the
replicationslots isn’t expectedto be particularly useful, since the contents of those slots willlikely be
badly out of date by the time the new master comes on line.
It’s also worth noting that the
pg_start_backup
function makes a file named
backup_label
in
the database cluster directory, which is removed by
pg_stop_backup
.This file will of course be
archived as a part of your backup dump file. The backup label file includes the label string you gave
to
pg_start_backup
,as wellas thetime at which
pg_start_backup
was run, and the name of the
starting WAL file. In case of confusion it is therefore possible to look inside a backup dump file and
determine exactly which backup session the dump file came from. However, this file is not merely
for your information; its presence and contents are critical to the proper operation of the system’s
recovery process.
It is also possible to make a backup dump while the server is stopped. In this case, you obviously
cannot use
pg_start_backup
or
pg_stop_backup
,and you will therefore be left to your own
devices to keep track of which backup dump is which and how far back the associated WAL files go.
It is generally better to follow the continuous archiving procedure above.
24.3.4. Recovering Using a Continuous Archive Backup
Okay, the worst has happened and you need to recover from your backup. Here is the procedure:
1. Stop the server, if it’s running.
2. If you have the space to do so, copy the whole cluster data directory and any tablespaces to a
temporary location in case you need them later. Note that this precaution will require that you
575
Chapter 24. Backup and Restore
have enough free spaceonyour system tohold twocopies of your existing database. If youdonot
have enough space, you should at least save the contents of the cluster’s
pg_xlog
subdirectory,
as it might contain logs which were not archived before the system went down.
3. Remove all existing files and subdirectories under the cluster data directory and under the root
directories of any tablespaces you are using.
4. Restore the database files from your file system backup. Be sure that they are restored with the
right ownership (the database system user, not
root
!) and with the right permissions. If you
are using tablespaces, you should verify that the symbolic links in
pg_tblspc/
were correctly
restored.
5. Remove any files presentin
pg_xlog/
;these came from the file system backup and are therefore
probably obsolete rather than current. If youdidn’t archive
pg_xlog/
at all, then recreate itwith
proper permissions, being careful to ensure that you re-establish it as a symbolic link if you had
it set up that way before.
6. If you have unarchived WAL segment files that you saved in step 2, copy them into
pg_xlog/
.
(It is bestto copy them, not move them, so you still have the unmodified files if a problem occurs
and you have to start over.)
7. Create a recovery command file
recovery.conf
in the cluster data directory (see Chapter 26).
You might also want to temporarily modify
pg_hba.conf
to prevent ordinary users from con-
necting until you are sure the recovery was successful.
8. Start the server. The server will go into recovery mode and proceed to read through the archived
WAL files it needs. Should the recovery be terminated because of an external error, the server
can simply be restarted and it will continue recovery. Upon completion of the recovery process,
the server will rename
recovery.conf
to
recovery.done
(toprevent accidentally re-entering
recovery mode later) and then commence normal database operations.
9. Inspect the contents of the database to ensure you have recovered to the desired state. If not,
return to step 1. If all is well, allow your users to connect by restoring
pg_hba.conf
to normal.
The key partof allthis is toset upa recovery configuration file thatdescribes howyou wantto recover
and howfar the recovery should run. You can use
recovery.conf.sample
(normally located in the
installation’s
share/
directory) as a prototype. The one thing that you absolutely must specify in
recovery.conf
is the
restore_command
,which tells PostgreSQL how to retrieve archived WAL
file segments. Like the
archive_command
,this is a shell command string. It can contain
%f
,which
is replacedby the name of the desired log file, and
%p
,whichis replacedby the path name to copy the
logfile to. (Thepath nameis relativetothecurrent working directory, i.e., thecluster’s datadirectory.)
Write
%%
if you need to embed an actual
%
character in the command. The simplest useful command
is something like:
restore_command = ’cp /mnt/server/archivedir/%f %p’
which willcopypreviously archived WAL segments from thedirectory
/mnt/server/archivedir
.
Of course, you can use something much more complicated, perhaps even a shell script that requests
the operator to mount an appropriate tape.
It is important that the command return nonzero exit status on failure. The command will be called
requesting files that are not present in the archive; it must return nonzero when so asked. This is
not an error condition. An exception is that if the command was terminated by a signal (other than
SIGTERM, which is used as part of a database server shutdown) or an error by the shell (such as
command not found), then recovery will abort and the server will not start up.
576
Chapter 24. Backup and Restore
Notall of the requested files will be WAL segment files; you shouldalso expectrequests for files with
asuffix of
.backup
or
.history
.Also be aware that the base name of the
%p
path will be different
from
%f
;do not expect them to be interchangeable.
WAL segments that cannot be found in the archive will be sought in
pg_xlog/
;this allows use of
recent un-archived segments. However, segments that are available from the archive will be used in
preference to files in
pg_xlog/
.
Normally, recovery will proceed through all available WAL segments, thereby restoring the database
to the current point in time (or as close as possible given the available WAL segments). Therefore,
a normal recovery will end with a “file not found” message, the exact text of the error message
depending upon your choice of
restore_command
.You may also see an error message at the start
of recovery for a file named something like
00000001.history
.This is also normal and does not
indicate a problem in simple recovery situations; see Section 24.3.5 for discussion.
If you want to recover to some previous point in time (say, right before the junior DBA dropped
your main transaction table), just specify the required stopping point in
recovery.conf
.You can
specify the stop point, known as the “recovery target”, either by date/time, named restore point or
by completion of a specific transaction ID. As of this writing only the date/time and named restore
point options are very usable, since there are no tools to help you identify with any accuracy which
transaction ID to use.
Note: The stop point must be after the ending time of the base backup, i.e., the end time of
pg_stop_backup
.You cannot use a base backup to recover to a time when that backup was in
progress. (To recover to such a time, you must go back to your previous base backup and roll
forward from there.)
If recovery finds corrupted WAL data, recovery will halt at that point and the server will not start. In
such a case the recovery process could be re-run from the beginning, specifying a “recovery target”
before the point of corruptionsothat recoverycan complete normally. If recovery fails for an external
reason, such as a system crash or if the WAL archive has become inaccessible, then the recovery can
simply be restarted and it will restart almost from where it failed. Recovery restart works much like
checkpointing in normal operation: the server periodically forces all its state to disk, and then updates
the
pg_control
file to indicate that the already-processed WAL data need not be scanned again.
24.3.5. Timelines
The ability to restore the database to a previous point in time creates some complexities that are akin
to science-fiction stories about time travel and parallel universes. For example, in the original history
of thedatabase, suppose you droppeda critical tableat 5:15PM on Tuesdayevening, butdidn’t realize
your mistake until Wednesday noon. Unfazed, you get out your backup, restore to the point-in-time
5:14PM Tuesday evening, and are up and running. In this history of the database universe, you never
dropped the table. But suppose you later realize this wasn’t such a great idea, and would like toreturn
to sometime Wednesday morningin the original history. Youwon’t be able to if, while your database
was up-and-running, it overwrote some of the WAL segment files that led up to the time you now
wish you could get back to. Thus, to avoid this, you need to distinguish the series of WAL records
generated after you’ve done a point-in-time recovery from those that were generated in the original
database history.
To dealwith this problem, PostgreSQL has a notion of timelines. Whenever an archive recovery com-
pletes, a new timeline is created to identify the series of WAL records generated after that recovery.
The timeline ID number is part of WAL segment file names so a new timeline does not overwrite the
577
Documents you may be interested
Documents you may be interested