Changeset ec36247

Timestamp:

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

Author:

Jason Gross <jasongross9@gmail.com>

Branches:

master

Children:

77beb3c

Parents:

e47e1b0

git-author:

Jason Gross <jgross@mit.edu> (09/09/12 20:44:13)

git-committer:

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

Message:

Defer failed log messages

Previously, when we failed to open a logging file, we errored, and
dropped the log message.  This commit makes it so that, if the reason we
failed was a permissions error, we instead add the log entry to a queue
of messages to be logged eventually, and inform the user that logging
has been suspended.  The user must run :flush-logs to resume logging.

If :flush-log has an fopen that fails with EPERM or EACCES, we re-defer
messages and inform the user.

On shutdown, BarnOwl will attempt to log all messages currently in the
queue one last time.

Files:

• commands.c (modified) (2 diffs)
• logging.c (modified) (6 diffs)

commands.c

@@ -487 +487 @@
               "\n"
               "SEE ALSO: aaway, zaway"),
+
+  OWLCMD_VOID("flush-logs", owl_command_flushlogs, OWL_CTX_ANY,
+              "flush the queue of messages waiting to be logged",
+              "",
+              "If BarnOwl failed to log a file, this command tells\n"
+              "BarnOwl to try logging the messages that have since\n"
+              "come in, and to resume logging normally."),
 
   OWLCMD_ARGS("load-subs", owl_command_loadsubs, OWL_CTX_ANY,
@@ -1435 +1442 @@
 {
   owl_function_unsuball();
+}
+
+void owl_command_flushlogs(void)
+{
+  owl_log_flush_logs();
 }
 

logging.c

@@ -11 +11 @@
 static GMainLoop *log_loop;
 static GThread *logging_thread;
+bool defer_logs;
+static GQueue *deferred_entry_queue;
 
 /* This is now the one function that should be called to log a
@@ -164 +166 @@
 }
 
-static void owl_log_write_entry(gpointer data)
-{
-  owl_log_entry *msg = (owl_log_entry*)data;
+static CALLER_OWN owl_log_entry *owl_log_new_entry(const char *buffer, const char *filename)
+{
+  owl_log_entry *log_msg = g_slice_new(owl_log_entry);
+  log_msg->message = g_strdup(buffer);
+  log_msg->filename = g_strdup(filename);
+  return log_msg;
+}
+
+static void owl_log_deferred_enqueue_message(const char *buffer, const char *filename)
+{
+  g_queue_push_tail(deferred_entry_queue, owl_log_new_entry(buffer, filename));
+}
+
+/* write out the entry if possible
+ * return 0 on success, errno on failure to open
+ */
+static int owl_log_try_write_entry(owl_log_entry *msg)
+{
   FILE *file = NULL;
   file = fopen(msg->filename, "a");
   if (!file) {
-    owl_log_error("Unable to open file for logging (%s)", msg->filename);
-    return;
+    return errno;
   }
   fprintf(file, "%s", msg->message);
   fclose(file);
+  return 0;
 }
 
@@ -187 +204 @@
 }
 
+#if GLIB_CHECK_VERSION(2, 32, 0)
+#else
+static void owl_log_entry_free_gfunc(gpointer data, gpointer user_data)
+{
+  owl_log_entry_free(data);
+}
+#endif
+
+/* If we are deferring log messages, enqueue this entry for writing.
+ * Otherwise, try to write this log message, and, if it fails with
+ * EPERM or EACCES, go into deferred logging mode and queue an admin
+ * message.  If it fails with anything else, display an error message,
+ * but do not go into deferred logging mode. */
+static void owl_log_eventually_write_entry(gpointer data)
+{
+  int ret;
+  owl_log_entry *msg = (owl_log_entry*)data;
+  if (defer_logs) {
+    owl_log_deferred_enqueue_message(msg->message, msg->filename);
+  } else {
+    ret = owl_log_try_write_entry(msg);
+    if (ret == EPERM || ret == EACCES) {
+      defer_logs = true;
+      owl_log_error("Unable to open file for logging (%s): \n"
+                    "%s.  \n"
+                    "Consider renewing your tickets.  Logging has been \n"
+                    "suspended, and your messages will be saved.  To \n"
+                    "resume logging, use the command :flush-logs.\n\n",
+                    msg->filename,
+                    g_strerror(ret));
+      owl_log_deferred_enqueue_message(msg->message, msg->filename);
+    } else if (ret != 0) {
+      owl_log_error("Unable to open file for logging: %s (file %s)",
+                    g_strerror(ret),
+                    msg->filename);
+    }
+  }
+}
+
+/* tries to write the deferred log entries */
+static void owl_log_write_deferred_entries(gpointer data)
+{
+  owl_log_entry *entry;
+
+  defer_logs = false;
+  while (!g_queue_is_empty(deferred_entry_queue) && !defer_logs) {
+    entry = (owl_log_entry*)g_queue_pop_head(deferred_entry_queue);
+    owl_log_eventually_write_entry(entry);
+    owl_log_entry_free(entry);
+  }
+}
+
+void owl_log_flush_logs(void)
+{
+  owl_select_post_task(owl_log_write_deferred_entries, NULL, NULL, log_context);
+}
+
 void owl_log_enqueue_message(const char *buffer, const char *filename)
 {
-  owl_log_entry *log_msg = NULL; 
-  log_msg = g_slice_new(owl_log_entry);
-  log_msg->message = g_strdup(buffer);
-  log_msg->filename = g_strdup(filename);
-  owl_select_post_task(owl_log_write_entry, log_msg, 
+  owl_log_entry *log_msg = owl_log_new_entry(buffer, filename);
+  owl_select_post_task(owl_log_eventually_write_entry, log_msg,
                        owl_log_entry_free, log_context);
 }
@@ -435 +506 @@
 static gpointer owl_log_thread_func(gpointer data)
 {
+  log_context = g_main_context_new();
   log_loop = g_main_loop_new(log_context, FALSE);
   g_main_loop_run(log_loop);
@@ -440 +512 @@
 }
 
-void owl_log_init(void) 
+void owl_log_init(void)
 {
   log_context = g_main_context_new();
@@ -460 +532 @@
   }
 #endif
-  
+
+  deferred_entry_queue = g_queue_new();
 }
 
 static void owl_log_quit_func(gpointer data)
 {
+  /* flush the deferred logs queue, trying to write the
+   * entries to the disk one last time */
+  owl_log_write_deferred_entries(NULL);
+#if GLIB_CHECK_VERSION(2, 32, 0)
+  g_queue_free_full(deferred_entry_queue, owl_log_entry_free);
+#else
+  g_queue_foreach(deferred_entry_queue, owl_log_entry_free_gfunc, NULL);
+  g_queue_free(deferred_entry_queue);
+#endif
+
   g_main_loop_quit(log_loop);
 }