make exceptions more useful

Author: funbringer

testgres/consts.py

@@ -5,6 +5,7 @@
 LOGS_DIR = "logs"
 
 RECOVERY_CONF_FILE = "recovery.conf"
+PG_AUTO_CONF_FILE = "postgresql.auto.conf"
 PG_CONF_FILE = "postgresql.conf"
 HBA_CONF_FILE = "pg_hba.conf"
 

testgres/exceptions.py

@@ -1,47 +1,95 @@
 # coding: utf-8
 
+import six
 
-class TestgresException(Exception):
-    """
-    Base exception
-    """
 
-    pass
+@six.python_2_unicode_compatible
+class TestgresException(Exception):
+    def __str__(self):
+        s = super(TestgresException, self).__str__()
+        return six.text_type(s)
 
 
 class ExecUtilException(TestgresException):
-    """
-    Stores exit code
-    """
-
-    def __init__(self, message, exit_code=0):
+    def __init__(self,
+                 message=None,
+                 command=None,
+                 exit_code=0,
+                 out=None):
         super(ExecUtilException, self).__init__(message)
+
+        self.message = message
+        self.command = command
         self.exit_code = exit_code
+        self.out = out
 
+    def __str__(self):
+        msg = []
 
-class ClusterTestgresException(TestgresException):
-    pass
+        if self.message:
+            msg.append(self.message)
+
+        if self.command:
+            msg.append('Command: {}'.format(self.command))
+
+        if self.exit_code:
+            msg.append('Exit code: {}'.format(self.exit_code))
+
+        if self.out:
+            msg.append('----\n{}'.format(self.out))
+
+        return six.text_type('\n').join(msg)
 
 
 class QueryException(TestgresException):
+    def __init__(self, message=None, query=None):
+        super(QueryException, self).__init__(message)
+
+        self.message = message
+        self.query = query
+
+    def __str__(self):
+        msg = []
+
+        if self.message:
+            msg.append(self.message)
+
+        if self.query:
+            msg.append('Query: {}'.format(self.query))
+
+        return six.text_type('\n').join(msg)
+
+
+class TimeoutException(QueryException):
     pass
 
 
-class TimeoutException(TestgresException):
+class CatchUpException(QueryException):
     pass
 
 
 class StartNodeException(TestgresException):
-    pass
+    def __init__(self, message=None, files=None):
+        super(StartNodeException, self).__init__(message)
 
+        self.message = message
+        self.files = files
 
-class InitNodeException(TestgresException):
-    pass
+    def __str__(self):
+        msg = []
 
+        if self.message:
+            msg.append(self.message)
 
-class BackupException(TestgresException):
+        for key, value in six.iteritems(self.files or {}):
+            msg.append('{}\n----\n{}\n'.format(key, value))
+
+        return six.text_type('\n').join(msg)
+
+
+class InitNodeException(TestgresException):
     pass
 
 
-class CatchUpException(TestgresException):
+class BackupException(TestgresException):
     pass

testgres/node.py

@@ -24,6 +24,7 @@
     DATA_DIR, \
     LOGS_DIR, \
     PG_CONF_FILE, \
+    PG_AUTO_CONF_FILE, \
     HBA_CONF_FILE, \
     RECOVERY_CONF_FILE, \
     PG_LOG_FILE, \
@@ -215,22 +216,18 @@ def _maybe_stop_logger(self):
         if self._logger:
             self._logger.stop()
 
-    def _format_verbose_error(self, message=None):
-        # list of important files + N of last lines
+    def _collect_special_files(self):
+        result = {}
+
+        # list of important files + last N lines
         files = [
             (os.path.join(self.data_dir, PG_CONF_FILE), 0),
-            (os.path.join(self.data_dir, HBA_CONF_FILE), 0),
+            (os.path.join(self.data_dir, PG_AUTO_CONF_FILE), 0),
             (os.path.join(self.data_dir, RECOVERY_CONF_FILE), 0),
+            (os.path.join(self.data_dir, HBA_CONF_FILE), 0),
             (self.pg_log_name, TestgresConfig.error_log_lines)
         ]
 
-        error_text = ""
-
-        # append message if asked to
-        if message:
-            error_text += message
-            error_text += '\n' * 2
-
         for f, num_lines in files:
             # skip missing files
             if not os.path.exists(f):
@@ -244,10 +241,10 @@ def _format_verbose_error(self, message=None):
                     # read whole file
                     lines = _f.read().decode('utf-8')
 
-                # append contents
-                error_text += u"{}:\n----\n{}\n".format(f, lines)
+                # fill dict
+                result[f] = lines
 
-        return error_text
+        return result
 
     def init(self,
              fsync=False,
@@ -429,7 +426,8 @@ def get_pid(self):
         """
 
         if self.status():
-            with io.open(os.path.join(self.data_dir, 'postmaster.pid')) as f:
+            pid_file = os.path.join(self.data_dir, 'postmaster.pid')
+            with io.open(pid_file) as f:
                 return int(f.readline())
 
         # for clarity
@@ -478,8 +476,9 @@ def start(self, params=[]):
         try:
             execute_utility(_params, self.utils_log_name)
         except ExecUtilException as e:
-            msg = self._format_verbose_error('Cannot start node')
-            raise_from(StartNodeException(msg), e)
+            msg = 'Cannot start node'
+            files = self._collect_special_files()
+            raise_from(StartNodeException(msg, files), e)
 
         self._maybe_start_logger()
 
@@ -533,8 +532,9 @@ def restart(self, params=[]):
         try:
             execute_utility(_params, self.utils_log_name)
         except ExecUtilException as e:
-            msg = self._format_verbose_error('Cannot restart node')
-            raise_from(StartNodeException(msg), e)
+            msg = 'Cannot restart node'
+            files = self._collect_special_files()
+            raise_from(StartNodeException(msg, files), e)
 
         self._maybe_start_logger()
 
@@ -695,7 +695,7 @@ def safe_psql(self,
                                   username=username,
                                   input=input)
         if ret:
-            raise QueryException((err or b'').decode('utf-8'))
+            raise QueryException((err or b'').decode('utf-8'), query)
 
         return out
 
@@ -793,13 +793,13 @@ def poll_query_until(self,
                     return    # done
 
                 if res is None:
-                    raise QueryException('Query returned None')
+                    raise QueryException('Query returned None', query)
 
                 if len(res) == 0:
-                    raise QueryException('Query returned 0 rows')
+                    raise QueryException('Query returned 0 rows', query)
 
                 if len(res[0]) == 0:
-                    raise QueryException('Query returned 0 columns')
+                    raise QueryException('Query returned 0 columns', query)
 
                 if res[0][0] == expected:
                     return    # done
@@ -916,7 +916,7 @@ def catchup(self, dbname=None, username=None):
                 username=username,
                 max_attempts=0)    # infinite
         except Exception as e:
-            raise_from(CatchUpException('Failed to catch up'), e)
+            raise_from(CatchUpException("Failed to catch up", poll_lsn), e)
 
     def pgbench(self,
                 dbname=None,

testgres/utils.py

@@ -90,29 +90,31 @@ def execute_utility(args, logfile):
     out, _ = process.communicate()
     out = '' if not out else out.decode('utf-8')
 
+    # format command
+    command = u' '.join(args)
+
     # write new log entry if possible
     try:
         with io.open(logfile, 'a') as file_out:
-            # write util's name and args
-            file_out.write(u' '.join(args))
+            file_out.write(command)
 
-            # write output
             if out:
+                # comment-out lines
+                lines = ('# ' + l for l in out.splitlines())
                 file_out.write(u'\n')
-                file_out.write(out)
+                file_out.writelines(lines)
 
-            # finally, a separator
             file_out.write(u'\n')
     except IOError:
         pass
 
-    # format exception, if needed
-    error_code = process.returncode
-    if error_code:
-        error_text = (u"{} failed with exit code {}\n"
-                      u"log:\n----\n{}\n").format(args[0], error_code, out)
-
-        raise ExecUtilException(error_text, error_code)
+    exit_code = process.returncode
+    if exit_code:
+        message = 'Failed to execute utility'
+        raise ExecUtilException(message=message,
+                                command=command,
+                                exit_code=exit_code,
+                                out=out)
 
     return out