Changeset 874fd19

Timestamp:

Aug 5, 2017, 11:21:53 PM (7 years ago)

Author:

Jason Gross <jasongross9@gmail.com>

Branches:

master

Children:

1917e53

Parents:

edb14cc

git-author:

Jason Gross <jgross@mit.edu> (12/04/16 12:40:17)

git-committer:

Jason Gross <jasongross9@gmail.com> (08/05/17 23:21:53)

Message:

Fix the sense of drop_failed_logs

Previously, :flush-logs was dropping failed logs, while :flush-logs -f
was not.  Additionally, :flush-logs -f was enqueing the failed messages
at the end of the queue, breaking message ordering.

This commit fixes both of these issues.  I chose to optimize for the
case where :flush-logs is run without renewing tickets (where the
correct behavior is to stop at the first message that fails), rather
than the case where the user is logging to a directory they never have
permission to access (where the correct behavior is to try to log all of
the messages, and keep only the ones that fail).  This way, we won't
ever flood the system with lots of requests for files we don't have
permissions to access, and the user will have to :flush-logs -f if they
log to a directory they don't have permission to write to.

File:

• logging.c (modified) (3 diffs)

logging.c

@@ -195 +195 @@
 {
   g_queue_push_tail(deferred_entry_queue, owl_log_new_entry(buffer, filename));
+}
+
+static void owl_log_deferred_enqueue_first_message(const char *buffer, const char *filename)
+{
+  g_queue_push_head(deferred_entry_queue, owl_log_new_entry(buffer, filename));
 }
 
@@ -259 +264 @@
                     msg->filename,
                     g_strerror(ret));
-      owl_log_deferred_enqueue_message(msg->message, msg->filename);
+      /* If we were not in deferred logging mode, either the queue should be
+       * empty, or we are attempting to log a message that we just popped off
+       * the head of the queue.  Either way, we should enqueue this message as
+       * the first message in the queue, rather than the last, so that we
+       * preserve message ordering. */
+      owl_log_deferred_enqueue_first_message(msg->message, msg->filename);
     } else if (ret != 0) {
       owl_log_file_error(msg, ret);
@@ -279 +289 @@
     logged_at_least_one_message = true;
     entry = (owl_log_entry*)g_queue_pop_head(deferred_entry_queue);
-    if (drop_failed_logs) {
+    if (!drop_failed_logs) {
+      /* Attempt to write the log entry.  If it fails, re-queue the entry at
+       * the head of the queue. */
       owl_log_eventually_write_entry(entry);
     } else {
+      /* Attempt to write the log entry. If it fails, print an error message,
+       * drop the log, and keep going through the queue. */
       ret = owl_log_try_write_entry(entry);
       if (ret != 0) {