Ticket #2304: backup.2.patch

trac/db/api.py

@@ -16 +16 @@
 
 import os
 import urllib
+import time
 
 from trac.config import Option, IntOption
 from trac.core import *
@@ -48 +49 @@
     def to_sql(table):
         """Return the DDL statements necessary to create the specified table,
         including indices."""
+        
+    def backup(dest):
+        """Backup the database to a location defined by trac.backup_dir"""
 
 
 class DatabaseManager(Component):
@@ -59 +63 @@
         [wiki:TracEnvironment#DatabaseConnectionStrings string] for this
         project""")
 
+    backup_dir = Option('trac', 'backup_dir', 'db',
+        """Database backup location""")
+
     timeout = IntOption('trac', 'timeout', '20',
         """Timeout value for database connection, in seconds.
         Use '0' to specify ''no timeout''. ''(Since 0.11)''""")
@@ -81 +88 @@
             self._cnx_pool.shutdown(tid)
             if not tid:
                 self._cnx_pool = None
+                
+    def backup(self, dest=None):
+        connector, args = self._get_connector()
+        if not dest:
+            backup_dir = self.backup_dir
+            if backup_dir[0] != "/":
+                backup_dir = os.path.join(self.env.path, backup_dir)
+            db_str = self.config.get('trac', 'database')
+            db_name, db_path = db_str.split(":",1)
+            dest_name = '%s.%i.%d.bak' % (db_name, self.env.get_version(),int(time.time()))
+            dest = os.path.join(backup_dir, dest_name)
+        else:
+            backup_dir = os.path.dirname(dest)
+        if not os.path.exists(backup_dir):
+            os.makedirs(backup_dir)
+        connector.backup(dest)
 
     def _get_connector(self): ### FIXME: Make it public?
         scheme, args = _parse_db_str(self.connection_uri)

trac/db/mysql_backend.py

@@ -142 +142 @@
                   '_'.join(index.columns), table.name,
                   self._collist(table, index.columns))
 
+    def backup(self, dest):
+        raise TracError("MySQL backup not implemented")
 
 class MySQLConnection(ConnectionWrapper):
     """Connection wrapper for MySQL."""

trac/db/postgres_backend.py

@@ -14 +14 @@
 #
 # Author: Christopher Lenz <cmlenz@gmx.de>
 
-import re
+import re, sys, os, time
 
 from trac.core import *
-from trac.db.api import IDatabaseConnector
+from trac.config import Option
+from trac.db.api import IDatabaseConnector, _parse_db_str
 from trac.db.util import ConnectionWrapper
 from trac.util import get_pkginfo
+from subprocess import Popen, PIPE
 
 psycopg = None
 PgSQL = None
@@ -33 +35 @@
 
     implements(IDatabaseConnector)
 
+    pg_dump_bin = Option('trac', 'pg_dump_bin', 'pg_dump',
+        """Location of pg_dump for Postgres database backups""")
+    compression = Option('trac', 'backup_compression', '8',
+        """Gzip backup compression level (if supported by backend)""")
+
     def __init__(self):
         self._version = None
 
@@ -65 +72 @@
         cnx = self.get_connection(path, user, password, host, port, params)
         cursor = cnx.cursor()
         if cnx.schema:
-            cursor.execute('CREATE SCHEMA "%s"' % cnx.schema)
-            cursor.execute('SET search_path TO %s', (cnx.schema,))
+            try:
+                cursor.execute('CREATE SCHEMA "%s"' % cnx.schema)
+                cursor.execute('SET search_path TO %s', (cnx.schema,))
+                cnx.commit()
+            except Exception, e:
+                cnx.rollback()
         from trac.db_default import schema
         for table in schema:
             for stmt in self.to_sql(table):
@@ -93 +104 @@
             yield 'CREATE %s INDEX "%s_%s_idx" ON "%s" ("%s")' % (unique, table.name, 
                    '_'.join(index.columns), table.name, '","'.join(index.columns))
 
+    def backup(self, dest_file):
+        # pg_dump -n schemaname dbname | gzip > filename.gz
+        db_url = self.env.config.get('trac', 'database')
+        scheme, db_prop = _parse_db_str(db_url)
+        db_name = os.path.basename(db_prop['path'])
+        args = [self.pg_dump_bin, '-C', '-d', '-x', '-Z', self.compression,
+                '-U', db_prop['user'],
+                '-h', db_prop['host'],
+                '-p', str(db_prop['port'])]
+
+        if 'schema' in db_prop['params']:
+            args.extend(['-n', db_prop['params']['schema'], db_name])
+        else:
+            args.extend([db_name])
+
+        dest_file = "%s.gz" % (dest_file,)
+        args.extend(['>', dest_file])
+        if sys.platform == 'win':
+            # XXX TODO verify on windows
+            args = ['cmd', '/c', ' '.join(args)]
+        else:
+            args = ['bash', '-c', ' '.join(args)]
+        
+        environ = os.environ.copy()
+        environ['PGPASSWORD'] = db_prop['password']
+        #print >> sys.stderr, "backup command %r" % (args,)
+        #print >> sys.stderr, "backup props %r" % (db_prop,)
+        #print >> sys.stderr, "backup to %s" % dest_file
+        p = Popen(args, env=environ, shell=False, bufsize=0, stdin=None, stdout=PIPE, stderr=PIPE, close_fds=True)
+        p.wait()
+        p.stdout.close()
+        p.stderr.close()
+        if not os.path.exists(dest_file):
+            raise TracError("Backup attempt failed")
 
 class PostgreSQLConnection(ConnectionWrapper):
     """Connection wrapper for PostgreSQL."""

trac/db/sqlite_backend.py

@@ -146 +146 @@
     def to_sql(cls, table):
         return _to_sql(table)
 
+    def backup(self, dest_file):
+        """Simple SQLite-specific backup of the database.
+
+        @param dest: Destination file; if not specified, the backup is stored in
+                     a file called db_name.trac_version.bak
+        """
+        import shutil
+        db_str = self.config.get('trac', 'database')
+        db_name = os.path.join(self.env.path, db_str[7:])
+        shutil.copy(db_name, dest_file)
+        if not os.path.exists(dest_file):
+            raise TracError("Backup attempt failed")
 
 class SQLiteConnection(ConnectionWrapper):
     """Connection wrapper for SQLite."""

trac/env.py

@@ -414 +414 @@
         @param dest: Destination file; if not specified, the backup is stored in
                      a file called db_name.trac_version.bak
         """
-        import shutil
-
-        db_str = self.config.get('trac', 'database')
-        if not db_str.startswith('sqlite:'):
-            raise TracError(_('Can only backup sqlite databases'))
-        db_name = os.path.join(self.path, db_str[7:])
-        if not dest:
-            dest = '%s.%i.bak' % (db_name, self.get_version())
-        shutil.copy (db_name, dest)
+        DatabaseManager(self).backup(dest)
 
     def needs_upgrade(self):
         """Return whether the environment needs to be upgraded."""

new file trac/tests/backup.py

@@ +1 @@
+import trac
+from trac import db_default
+from trac.db import sqlite_backend
+from trac.env import Environment
+
+import os.path
+import unittest
+import tempfile
+import shutil
+
+from trac.tests.functional.testenv import FunctionalTestEnvironment
+
+class DatabaseBackupTestCase(unittest.TestCase):
+
+    env_class = FunctionalTestEnvironment
+
+    def setUp(self):
+        trac_source_tree = os.path.normpath(os.path.join(trac.__file__, '..',
+                                                     '..'))
+        port = 8000 + os.getpid() % 1000
+        dirname = "testenv%s" % port
+        dirname = os.path.join(trac_source_tree, dirname)
+
+        baseurl = "http://127.0.0.1:%s" % port
+        self._testenv = self.env_class(dirname, port, baseurl)
+
+    def tearDown(self):
+        """remove the test environment"""
+        self._testenv.destroy()
+
+    def test_backup(self):
+        """Testing backup"""
+        # raises TracError if backup fails
+        env = self._testenv.get_trac_environment()
+        env.backup()
+
+
+
+def suite():
+    return unittest.makeSuite(DatabaseBackupTestCase,'test')
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='suite')