X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Frrd_daemon.c;h=7a802203d140c22681ededf50de9ced3eec128d6;hb=0f56f88a65b4e0eba572afcc55be8ca4f9902812;hp=3163e1865629abe2879f0bcaeb5dd583f202c66f;hpb=28e399e75eb5a26a5ab1b65b7b18b4cfd69e263d;p=rrdtool.git

diff --git a/src/rrd_daemon.c b/src/rrd_daemon.c
index 3163e18..7a80220 100644
--- a/src/rrd_daemon.c
+++ b/src/rrd_daemon.c
@@ -66,6 +66,9 @@
 #include <stdio.h>
 #include <unistd.h>
 #include <string.h>
+#include <strings.h>
+#include <stdint.h>
+#include <inttypes.h>
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -162,6 +165,11 @@ static char *config_base_dir = NULL;
 static char **config_listen_address_list = NULL;
 static int config_listen_address_list_len = 0;
 
+static uint64_t stats_queue_length = 0;
+static uint64_t stats_updates_written = 0;
+static uint64_t stats_data_sets_written = 0;
+static pthread_mutex_t stats_lock = PTHREAD_MUTEX_INITIALIZER;
+
 /* 
  * Functions
  */
@@ -215,6 +223,84 @@ static int remove_pidfile (void) /* {{{ */
   return (errno);
 } /* }}} int remove_pidfile */
 
+static ssize_t sread (int fd, void *buffer_void, size_t buffer_size) /* {{{ */
+{
+  char    *buffer;
+  size_t   buffer_used;
+  size_t   buffer_free;
+  ssize_t  status;
+
+  buffer       = (char *) buffer_void;
+  buffer_used  = 0;
+  buffer_free  = buffer_size;
+
+  while (buffer_free > 0)
+  {
+    status = read (fd, buffer + buffer_used, buffer_free);
+    if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR)))
+      continue;
+
+    if (status < 0)
+      return (-1);
+
+    if (status == 0)
+      return (0);
+
+    assert ((0 > status) || (buffer_free >= (size_t) status));
+
+    buffer_free = buffer_free - status;
+    buffer_used = buffer_used + status;
+
+    if (buffer[buffer_used - 1] == '\n')
+      break;
+  }
+
+  assert (buffer_used > 0);
+
+  if (buffer[buffer_used - 1] != '\n')
+  {
+    errno = ENOBUFS;
+    return (-1);
+  }
+
+  buffer[buffer_used - 1] = 0;
+
+  /* Fix network line endings. */
+  if ((buffer_used > 1) && (buffer[buffer_used - 2] == '\r'))
+  {
+    buffer_used--;
+    buffer[buffer_used - 1] = 0;
+  }
+
+  return (buffer_used);
+} /* }}} ssize_t sread */
+
+static ssize_t swrite (int fd, const void *buf, size_t count) /* {{{ */
+{
+  const char *ptr;
+  size_t      nleft;
+  ssize_t     status;
+
+  ptr   = (const char *) buf;
+  nleft = count;
+
+  while (nleft > 0)
+  {
+    status = write (fd, (const void *) ptr, nleft);
+
+    if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR)))
+      continue;
+
+    if (status < 0)
+      return (status);
+
+    nleft = nleft - status;
+    ptr   = ptr   + status;
+  }
+
+  return (0);
+} /* }}} ssize_t swrite */
+
 /*
  * enqueue_cache_item:
  * `cache_lock' must be acquired before calling this function!
@@ -222,6 +308,8 @@ static int remove_pidfile (void) /* {{{ */
 static int enqueue_cache_item (cache_item_t *ci, /* {{{ */
     queue_side_t side)
 {
+  int did_insert = 0;
+
   RRDD_LOG (LOG_DEBUG, "enqueue_cache_item: Adding %s to the update queue.",
       ci->file);
 
@@ -241,6 +329,8 @@ static int enqueue_cache_item (cache_item_t *ci, /* {{{ */
 
       if (cache_queue_tail == NULL)
         cache_queue_tail = cache_queue_head;
+
+      did_insert = 1;
     }
     else if (cache_queue_head == ci)
     {
@@ -279,10 +369,19 @@ static int enqueue_cache_item (cache_item_t *ci, /* {{{ */
     else
       cache_queue_tail->next = ci;
     cache_queue_tail = ci;
+
+    did_insert = 1;
   }
 
   ci->flags |= CI_FLAGS_IN_QUEUE;
 
+  if (did_insert)
+  {
+    pthread_mutex_lock (&stats_lock);
+    stats_queue_length++;
+    pthread_mutex_unlock (&stats_lock);
+  }
+
   return (0);
 } /* }}} int enqueue_cache_item */
 
@@ -443,6 +542,11 @@ static void *queue_thread_main (void *args __attribute__((unused))) /* {{{ */
       cache_queue_tail = NULL;
     ci->next = NULL;
 
+    pthread_mutex_lock (&stats_lock);
+    assert (stats_queue_length > 0);
+    stats_queue_length--;
+    pthread_mutex_unlock (&stats_lock);
+
     pthread_mutex_unlock (&cache_lock);
 
     RRDD_LOG (LOG_DEBUG, "queue_thread_main: rrd_update (%s, %i, %p)",
@@ -460,6 +564,11 @@ static void *queue_thread_main (void *args __attribute__((unused))) /* {{{ */
     for (i = 0; i < values_num; i++)
       free (values[i]);
 
+    pthread_mutex_lock (&stats_lock);
+    stats_updates_written++;
+    stats_data_sets_written += values_num;
+    pthread_mutex_unlock (&stats_lock);
+
     pthread_mutex_lock (&cache_lock);
     pthread_cond_broadcast (&flush_cond);
   } /* while (do_shutdown == 0) */
@@ -486,6 +595,9 @@ static int buffer_get_field (char **buffer_ret, /* {{{ */
   field = *buffer_ret;
   field_size = 0;
 
+  if (buffer_size <= 0)
+    return (-1);
+
   /* This is ensured by `handle_request'. */
   assert (buffer[buffer_size - 1] == ' ');
 
@@ -567,6 +679,166 @@ static int flush_file (const char *filename) /* {{{ */
   return (0);
 } /* }}} int flush_file */
 
+static int handle_request_help (int fd, /* {{{ */
+    char *buffer, size_t buffer_size)
+{
+  int status;
+  char **help_text;
+  size_t help_text_len;
+  char *command;
+  size_t i;
+
+  char *help_help[] =
+  {
+    "4 Command overview\n",
+    "FLUSH <filename>\n",
+    "HELP [<command>]\n",
+    "UPDATE <filename> <values> [<values> ...]\n",
+    "STATS\n"
+  };
+  size_t help_help_len = sizeof (help_help) / sizeof (help_help[0]);
+
+  char *help_flush[] =
+  {
+    "4 Help for FLUSH\n",
+    "Usage: FLUSH <filename>\n",
+    "\n",
+    "Adds the given filename to the head of the update queue and returns\n",
+    "after is has been dequeued.\n"
+  };
+  size_t help_flush_len = sizeof (help_flush) / sizeof (help_flush[0]);
+
+  char *help_update[] =
+  {
+    "9 Help for UPDATE\n",
+    "Usage: UPDATE <filename> <values> [<values> ...]\n"
+    "\n",
+    "Adds the given file to the internal cache if it is not yet known and\n",
+    "appends the given value(s) to the entry. See the rrdcached(1) manpage\n",
+    "for details.\n",
+    "\n",
+    "Each <values> has the following form:\n",
+    "  <values> = <time>:<value>[:<value>[...]]\n",
+    "See the rrdupdate(1) manpage for details.\n"
+  };
+  size_t help_update_len = sizeof (help_update) / sizeof (help_update[0]);
+
+  char *help_stats[] =
+  {
+    "4 Help for STATS\n",
+    "Usage: STATS\n",
+    "\n",
+    "Returns some performance counters, see the rrdcached(1) manpage for\n",
+    "a description of the values.\n"
+  };
+  size_t help_stats_len = sizeof (help_stats) / sizeof (help_stats[0]);
+
+  status = buffer_get_field (&buffer, &buffer_size, &command);
+  if (status != 0)
+  {
+    help_text = help_help;
+    help_text_len = help_help_len;
+  }
+  else
+  {
+    if (strcasecmp (command, "update") == 0)
+    {
+      help_text = help_update;
+      help_text_len = help_update_len;
+    }
+    else if (strcasecmp (command, "flush") == 0)
+    {
+      help_text = help_flush;
+      help_text_len = help_flush_len;
+    }
+    else if (strcasecmp (command, "stats") == 0)
+    {
+      help_text = help_stats;
+      help_text_len = help_stats_len;
+    }
+    else
+    {
+      help_text = help_help;
+      help_text_len = help_help_len;
+    }
+  }
+
+  for (i = 0; i < help_text_len; i++)
+  {
+    status = swrite (fd, help_text[i], strlen (help_text[i]));
+    if (status < 0)
+    {
+      status = errno;
+      RRDD_LOG (LOG_ERR, "handle_request_help: swrite returned an error.");
+      return (status);
+    }
+  }
+
+  return (0);
+} /* }}} int handle_request_help */
+
+static int handle_request_stats (int fd, /* {{{ */
+    char *buffer __attribute__((unused)),
+    size_t buffer_size __attribute__((unused)))
+{
+  int status;
+  char outbuf[4096];
+
+  uint64_t copy_queue_length;
+  uint64_t copy_updates_written;
+  uint64_t copy_data_sets_written;
+
+  uint64_t tree_nodes_number;
+  uint64_t tree_depth;
+
+  pthread_mutex_lock (&stats_lock);
+  copy_queue_length       = stats_queue_length;
+  copy_updates_written    = stats_updates_written;
+  copy_data_sets_written  = stats_data_sets_written;
+  pthread_mutex_unlock (&stats_lock);
+
+  pthread_mutex_lock (&cache_lock);
+  tree_nodes_number = (uint64_t) g_tree_nnodes (cache_tree);
+  tree_depth        = (uint64_t) g_tree_height (cache_tree);
+  pthread_mutex_unlock (&cache_lock);
+
+#define RRDD_STATS_SEND \
+  outbuf[sizeof (outbuf) - 1] = 0; \
+  status = swrite (fd, outbuf, strlen (outbuf)); \
+  if (status < 0) \
+  { \
+    status = errno; \
+    RRDD_LOG (LOG_INFO, "handle_request_stats: swrite returned an error."); \
+    return (status); \
+  }
+
+  strncpy (outbuf, "5 Statistics follow\n", sizeof (outbuf));
+  RRDD_STATS_SEND;
+
+  snprintf (outbuf, sizeof (outbuf),
+      "QueueLength: %"PRIu64"\n", copy_queue_length);
+  RRDD_STATS_SEND;
+
+  snprintf (outbuf, sizeof (outbuf),
+      "UpdatesWritten: %"PRIu64"\n", copy_updates_written);
+  RRDD_STATS_SEND;
+
+  snprintf (outbuf, sizeof (outbuf),
+      "DataSetsWritten: %"PRIu64"\n", copy_data_sets_written);
+  RRDD_STATS_SEND;
+
+  snprintf (outbuf, sizeof (outbuf),
+      "TreeNodesNumber: %"PRIu64"\n", tree_nodes_number);
+  RRDD_STATS_SEND;
+
+  snprintf (outbuf, sizeof (outbuf),
+      "TreeDepth: %"PRIu64"\n", tree_depth);
+  RRDD_STATS_SEND;
+
+  return (0);
+#undef RRDD_STATS_SEND
+} /* }}} int handle_request_stats */
+
 static int handle_request_flush (int fd, /* {{{ */
     char *buffer, size_t buffer_size)
 {
@@ -577,26 +849,27 @@ static int handle_request_flush (int fd, /* {{{ */
   status = buffer_get_field (&buffer, &buffer_size, &file);
   if (status != 0)
   {
-    RRDD_LOG (LOG_INFO, "handle_request_flush: Cannot get file name.");
-    return (-1);
+    strncpy (result, "-1 Usage: flush <filename>\n", sizeof (result));
   }
-
-  status = flush_file (file);
-  if (status == 0)
-    snprintf (result, sizeof (result), "0 Successfully flushed %s.\n", file);
-  else if (status == ENOENT)
-    snprintf (result, sizeof (result), "-1 No such file: %s.\n", file);
-  else if (status < 0)
-    strncpy (result, "-1 Internal error.\n", sizeof (result));
   else
-    snprintf (result, sizeof (result), "-1 Failed with status %i.\n", status);
+  {
+    status = flush_file (file);
+    if (status == 0)
+      snprintf (result, sizeof (result), "0 Successfully flushed %s.\n", file);
+    else if (status == ENOENT)
+      snprintf (result, sizeof (result), "-1 No such file: %s.\n", file);
+    else if (status < 0)
+      strncpy (result, "-1 Internal error.\n", sizeof (result));
+    else
+      snprintf (result, sizeof (result), "-1 Failed with status %i.\n", status);
+  }
   result[sizeof (result) - 1] = 0;
 
-  status = write (fd, result, strlen (result));
+  status = swrite (fd, result, strlen (result));
   if (status < 0)
   {
     status = errno;
-    RRDD_LOG (LOG_INFO, "handle_request_flush: write(2) returned an error.");
+    RRDD_LOG (LOG_INFO, "handle_request_flush: swrite returned an error.");
     return (status);
   }
 
@@ -615,13 +888,25 @@ static int handle_request_update (int fd, /* {{{ */
   cache_item_t *ci;
   char answer[4096];
 
+#define RRDD_UPDATE_SEND \
+  answer[sizeof (answer) - 1] = 0; \
+  status = swrite (fd, answer, strlen (answer)); \
+  if (status < 0) \
+  { \
+    status = errno; \
+    RRDD_LOG (LOG_INFO, "handle_request_update: swrite returned an error."); \
+    return (status); \
+  }
+
   now = time (NULL);
 
   status = buffer_get_field (&buffer, &buffer_size, &file);
   if (status != 0)
   {
-    RRDD_LOG (LOG_INFO, "handle_request_update: Cannot get file name.");
-    return (-1);
+    strncpy (answer, "-1 Usage: UPDATE <filename> <values> [<values> ...]\n",
+        sizeof (answer));
+    RRDD_UPDATE_SEND;
+    return (0);
   }
 
   pthread_mutex_lock (&cache_lock);
@@ -634,7 +919,10 @@ static int handle_request_update (int fd, /* {{{ */
     {
       pthread_mutex_unlock (&cache_lock);
       RRDD_LOG (LOG_ERR, "handle_request_update: malloc failed.");
-      return (-1);
+
+      strncpy (answer, "-1 malloc failed.\n", sizeof (answer));
+      RRDD_UPDATE_SEND;
+      return (0);
     }
     memset (ci, 0, sizeof (cache_item_t));
 
@@ -642,9 +930,12 @@ static int handle_request_update (int fd, /* {{{ */
     if (ci->file == NULL)
     {
       pthread_mutex_unlock (&cache_lock);
-      RRDD_LOG (LOG_ERR, "handle_request_update: malloc failed.");
       free (ci);
-      return (-1);
+      RRDD_LOG (LOG_ERR, "handle_request_update: strdup failed.");
+
+      strncpy (answer, "-1 strdup failed.\n", sizeof (answer));
+      RRDD_UPDATE_SEND;
+      return (0);
     }
 
     ci->values = NULL;
@@ -701,18 +992,18 @@ static int handle_request_update (int fd, /* {{{ */
 
   pthread_mutex_unlock (&cache_lock);
 
-  snprintf (answer, sizeof (answer), "0 Enqueued %i value(s)\n", values_num);
-  answer[sizeof (answer) - 1] = 0;
-
-  status = write (fd, answer, strlen (answer));
-  if (status < 0)
+  if (values_num < 1)
   {
-    status = errno;
-    RRDD_LOG (LOG_INFO, "handle_request_update: write(2) returned an error.");
-    return (status);
+    strncpy (answer, "-1 No values updated.\n", sizeof (answer));
   }
-
+  else
+  {
+    snprintf (answer, sizeof (answer), "0 Enqueued %i value%s\n", values_num,
+        (values_num == 1) ? "" : "s");
+  }
+  RRDD_UPDATE_SEND;
   return (0);
+#undef RRDD_UPDATE_SEND
 } /* }}} int handle_request_update */
 
 static int handle_request (int fd) /* {{{ */
@@ -723,31 +1014,19 @@ static int handle_request (int fd) /* {{{ */
   char *command;
   int status;
 
-  status = read (fd, buffer, sizeof (buffer));
+  status = (int) sread (fd, buffer, sizeof (buffer));
   if (status == 0)
   {
     return (1);
   }
   else if (status < 0)
   {
-    RRDD_LOG (LOG_ERR, "handle_request: read(2) failed.");
-    return (-1);
-  }
-  buffer_size = status;
-  assert (((size_t) buffer_size) <= sizeof (buffer));
-
-  if (buffer[buffer_size - 1] != '\n')
-  {
-    RRDD_LOG (LOG_INFO, "handle_request: malformed request.");
+    RRDD_LOG (LOG_ERR, "handle_request: sread failed.");
     return (-1);
   }
-
-  /* Accept Windows style line endings, too */
-  if ((buffer_size > 2) && (buffer[buffer_size - 2] == '\r'))
-  {
-    buffer_size--;
-    buffer[buffer_size - 1] = '\n';
-  }
+  buffer_size = (size_t) status;
+  assert (buffer_size <= sizeof (buffer));
+  assert (buffer[buffer_size - 1] == 0);
 
   /* Place the normal field separator at the end to simplify
    * `buffer_get_field's work. */
@@ -762,19 +1041,38 @@ static int handle_request (int fd) /* {{{ */
     return (-1);
   }
 
-  if (strcmp (command, "update") == 0)
+  if (strcasecmp (command, "update") == 0)
   {
     return (handle_request_update (fd, buffer_ptr, buffer_size));
   }
-  else if (strcmp (command, "flush") == 0)
+  else if (strcasecmp (command, "flush") == 0)
   {
     return (handle_request_flush (fd, buffer_ptr, buffer_size));
   }
+  else if (strcasecmp (command, "stats") == 0)
+  {
+    return (handle_request_stats (fd, buffer_ptr, buffer_size));
+  }
+  else if (strcasecmp (command, "help") == 0)
+  {
+    return (handle_request_help (fd, buffer_ptr, buffer_size));
+  }
   else
   {
-    RRDD_LOG (LOG_INFO, "handle_request: unknown command: %s.", buffer);
-    return (-1);
+    char result[4096];
+
+    snprintf (result, sizeof (result), "-1 Unknown command: %s\n", command);
+    result[sizeof (result) - 1] = 0;
+
+    status = swrite (fd, result, strlen (result));
+    if (status < 0)
+    {
+      RRDD_LOG (LOG_ERR, "handle_request: swrite failed.");
+      return (-1);
+    }
   }
+
+  return (0);
 } /* }}} int handle_request */
 
 static void *connection_thread_main (void *args /* {{{ */
@@ -1196,7 +1494,7 @@ static int daemonize (void) /* {{{ */
 
   memset (&sa_term, 0, sizeof (sa_term));
   sa_term.sa_handler = sig_term_handler;
-  sigaction (SIGINT, &sa_term, NULL);
+  sigaction (SIGTERM, &sa_term, NULL);
 
   memset (&sa_pipe, 0, sizeof (sa_pipe));
   sa_pipe.sa_handler = SIG_IGN;