command parser: Add support for the FLUSH command.

That is, implement the generic interface for FLUSH and switch the FLUSH
implementation to use the generic interface.

diff --git a/src/unixsock.c b/src/unixsock.c
index c8d1950..3098aa8 100644 (file)
--- a/src/unixsock.c
+++ b/src/unixsock.c
@@ -309,7 +309,7 @@ static void *us_handle_client (void *arg)
                }
                else if (strcasecmp (fields[0], "flush") == 0)
                {
-                       handle_flush (fhout, buffer);
+                       cmd_handle_flush (fhout, buffer);
                }
                else
                {

diff --git a/src/utils_cmd_flush.c b/src/utils_cmd_flush.c
index 1876150..cfd6a48 100644 (file)
--- a/src/utils_cmd_flush.c
+++ b/src/utils_cmd_flush.c
@@ -1,6 +1,6 @@
 /**
  * collectd - src/utils_cmd_flush.c
- * Copyright (C) 2008       Sebastian Harl
+ * Copyright (C) 2008, 2016 Sebastian Harl
  * Copyright (C) 2008       Florian Forster
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -33,44 +33,17 @@
 #include "utils_parse_option.h"
 #include "utils_cmd_flush.h"
 
-int handle_flush (FILE *fh, char *buffer)
+cmd_status_t cmd_parse_flush (size_t argc, char **argv,
+               cmd_flush_t *ret_flush, cmd_error_handler_t *err)
 {
-       int success = 0;
-       int error   = 0;
-
-       double timeout = 0.0;
-       char **plugins = NULL;
-       size_t plugins_num = 0;
-       char **identifiers = NULL;
-       size_t identifiers_num = 0;
-
-#define PRINT_TO_SOCK(fh, ...) \
-       do { \
-               if (fprintf (fh, __VA_ARGS__) < 0) { \
-                       char errbuf[1024]; \
-                       WARNING ("handle_flush: failed to write to socket #%i: %s", \
-                                       fileno (fh), sstrerror (errno, errbuf, sizeof (errbuf))); \
-                       strarray_free (plugins, plugins_num); \
-                       strarray_free (identifiers, identifiers_num); \
-                       return -1; \
-               } \
-               fflush(fh); \
-       } while (0)
-
-       if ((fh == NULL) || (buffer == NULL))
-               return (-1);
-
-       DEBUG ("utils_cmd_flush: handle_flush (fh = %p, buffer = %s);",
-                       (void *) fh, buffer);
-
-       if (strncasecmp ("FLUSH", buffer, strlen ("FLUSH")) != 0)
+       if (ret_flush == NULL)
        {
-               PRINT_TO_SOCK (fh, "-1 Cannot parse command.\n");
-               return (-1);
+               errno = EINVAL;
+               cmd_error (CMD_ERROR, err, "Invalid arguments to cmd_parse_flush.");
+               return (CMD_ERROR);
        }
-       buffer += strlen ("FLUSH");
 
-       while (*buffer != 0)
+       for (size_t i = 0; i < argc; i++)
        {
                char *opt_key;
                char *opt_value;
@@ -78,66 +51,134 @@ int handle_flush (FILE *fh, char *buffer)
 
                opt_key = NULL;
                opt_value = NULL;
-               status = parse_option (&buffer, &opt_key, &opt_value);
+               status = cmd_parse_option (argv[i], &opt_key, &opt_value, err);
                if (status != 0)
                {
-                       PRINT_TO_SOCK (fh, "-1 Parsing options failed.\n");
-                       strarray_free (plugins, plugins_num);
-                       strarray_free (identifiers, identifiers_num);
-                       return (-1);
+                       if (status == CMD_NO_OPTION)
+                               cmd_error (CMD_PARSE_ERROR, err,
+                                               "Invalid option string `%s'.", argv[i]);
+                       cmd_destroy_flush (ret_flush);
+                       return (CMD_PARSE_ERROR);
                }
 
                if (strcasecmp ("plugin", opt_key) == 0)
-                       strarray_add (&plugins, &plugins_num, opt_value);
+               {
+                       strarray_add (&ret_flush->plugins, &ret_flush->plugins_num,
+                                       opt_value);
+               }
                else if (strcasecmp ("identifier", opt_key) == 0)
-                       strarray_add (&identifiers, &identifiers_num, opt_value);
+               {
+                       identifier_t *id = realloc (ret_flush->identifiers,
+                                       (ret_flush->identifiers_num + 1) * sizeof (*id));
+                       if (id == NULL)
+                       {
+                               cmd_error (CMD_ERROR, err, "realloc failed.");
+                               cmd_destroy_flush (ret_flush);
+                               return (CMD_ERROR);
+                       }
+
+                       ret_flush->identifiers = id;
+                       id = ret_flush->identifiers + ret_flush->identifiers_num;
+                       ret_flush->identifiers_num++;
+                       if (parse_identifier (opt_value,
+                                               &id->host, &id->plugin, &id->plugin_instance,
+                                               &id->type, &id->type_instance) != 0)
+                       {
+                               cmd_error (CMD_PARSE_ERROR, err,
+                                               "Invalid identifier `%s'.", opt_value);
+                               cmd_destroy_flush (ret_flush);
+                               return (CMD_PARSE_ERROR);
+                       }
+               }
                else if (strcasecmp ("timeout", opt_key) == 0)
                {
                        char *endptr;
 
                        errno = 0;
                        endptr = NULL;
-                       timeout = strtod (opt_value, &endptr);
+                       ret_flush->timeout = strtod (opt_value, &endptr);
 
-                       if ((endptr == opt_value) || (errno != 0) || (!isfinite (timeout)))
+                       if ((endptr == opt_value) || (errno != 0)
+                                       || (!isfinite (ret_flush->timeout)))
                        {
-                               PRINT_TO_SOCK (fh, "-1 Invalid value for option `timeout': "
-                                               "%s\n", opt_value);
-                               strarray_free (plugins, plugins_num);
-                               strarray_free (identifiers, identifiers_num);
-                               return (-1);
+                               cmd_error (CMD_PARSE_ERROR, err,
+                                               "Invalid value for option `timeout': %s",
+                                               opt_value);
+                               cmd_destroy_flush (ret_flush);
+                               return (CMD_PARSE_ERROR);
                        }
-                       else if (timeout < 0.0)
+                       else if (ret_flush->timeout < 0.0)
                        {
-                               timeout = 0.0;
+                               ret_flush->timeout = 0.0;
                        }
                }
                else
                {
-                       PRINT_TO_SOCK (fh, "-1 Cannot parse option %s\n", opt_key);
-                       strarray_free (plugins, plugins_num);
-                       strarray_free (identifiers, identifiers_num);
-                       return (-1);
+                       cmd_error (CMD_PARSE_ERROR, err,
+                                       "Cannot parse option `%s'.", opt_key);
+                       cmd_destroy_flush (ret_flush);
+                       return (CMD_PARSE_ERROR);
                }
-       } /* while (*buffer != 0) */
+       }
+
+       return (CMD_OK);
+} /* cmd_status_t cmd_parse_flush */
 
-       for (size_t i = 0; (i == 0) || (i < plugins_num); i++)
+cmd_status_t cmd_handle_flush (FILE *fh, char *buffer)
+{
+       cmd_error_handler_t err = { cmd_error_fh, fh };
+       cmd_t cmd;
+
+       int success = 0;
+       int error   = 0;
+       int status;
+
+       size_t i;
+
+       if ((fh == NULL) || (buffer == NULL))
+               return (-1);
+
+       DEBUG ("utils_cmd_flush: cmd_handle_flush (fh = %p, buffer = %s);",
+                       (void *) fh, buffer);
+
+       if ((status = cmd_parse (buffer, &cmd, &err)) != CMD_OK)
+               return (status);
+       if (cmd.type != CMD_FLUSH)
+       {
+               cmd_error (CMD_UNKNOWN_COMMAND, &err, "Unexpected command: `%s'.",
+                               CMD_TO_STRING (cmd.type));
+               cmd_destroy (&cmd);
+               return (CMD_UNKNOWN_COMMAND);
+       }
+
+       for (i = 0; (i == 0) || (i < cmd.cmd.flush.plugins_num); i++)
        {
                char *plugin = NULL;
 
-               if (plugins_num != 0)
-                       plugin = plugins[i];
+               if (cmd.cmd.flush.plugins_num != 0)
+                       plugin = cmd.cmd.flush.plugins[i];
 
-               for (size_t j = 0; (j == 0) || (j < identifiers_num); j++)
+               for (size_t j = 0; (j == 0) || (j < cmd.cmd.flush.identifiers_num); j++)
                {
                        char *identifier = NULL;
+                       char buffer[1024];
                        int status;
 
-                       if (identifiers_num != 0)
-                               identifier = identifiers[j];
+                       if (cmd.cmd.flush.identifiers_num != 0)
+                       {
+                               identifier_t *id = cmd.cmd.flush.identifiers + j;
+                               if (format_name (buffer, sizeof (buffer),
+                                                       id->host, id->plugin, id->plugin_instance,
+                                                       id->type, id->type_instance) != 0)
+                               {
+                                       error++;
+                                       continue;
+                               }
+                               identifier = buffer;
+                       }
 
                        status = plugin_flush (plugin,
-                                       DOUBLE_TO_CDTIME_T (timeout),
+                                       DOUBLE_TO_CDTIME_T (cmd.cmd.flush.timeout),
                                        identifier);
                        if (status == 0)
                                success++;
@@ -146,14 +187,26 @@ int handle_flush (FILE *fh, char *buffer)
                }
        }
 
-       PRINT_TO_SOCK (fh, "0 Done: %i successful, %i errors\n",
+       cmd_error (CMD_OK, &err, "Done: %i successful, %i errors",
                        success, error);
 
-       strarray_free (plugins, plugins_num);
-       strarray_free (identifiers, identifiers_num);
+       cmd_destroy (&cmd);
        return (0);
 #undef PRINT_TO_SOCK
-} /* int handle_flush */
+} /* cmd_status_t cmd_handle_flush */
+
+void cmd_destroy_flush (cmd_flush_t *flush)
+{
+       if (flush == NULL)
+               return;
+
+       strarray_free (flush->plugins, flush->plugins_num);
+       flush->plugins = NULL;
+       flush->plugins_num = 0;
+
+       sfree (flush->identifiers);
+       flush->identifiers_num = 0;
+} /* void cmd_destroy_flush */
 
 /* vim: set sw=4 ts=4 tw=78 noexpandtab : */
 

diff --git a/src/utils_cmd_flush.h b/src/utils_cmd_flush.h
index f43b257..2afa3c7 100644 (file)
--- a/src/utils_cmd_flush.h
+++ b/src/utils_cmd_flush.h
@@ -1,6 +1,6 @@
 /**
  * collectd - src/utils_cmd_flush.h
- * Copyright (C) 2008       Sebastian Harl
+ * Copyright (C) 2008, 2016 Sebastian Harl
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -29,7 +29,14 @@
 
 #include <stdio.h>
 
-int handle_flush (FILE *fh, char *buffer);
+#include "utils_cmds.h"
+
+cmd_status_t cmd_parse_flush (size_t argc, char **argv,
+               cmd_flush_t *ret_flush, cmd_error_handler_t *err);
+
+cmd_status_t cmd_handle_flush (FILE *fh, char *buffer);
+
+void cmd_destroy_flush (cmd_flush_t *flush);
 
 #endif /* UTILS_CMD_FLUSH_H */
 

diff --git a/src/utils_cmd_putval.h b/src/utils_cmd_putval.h
index cd62a1b..363194d 100644 (file)
--- a/src/utils_cmd_putval.h
+++ b/src/utils_cmd_putval.h
@@ -33,7 +33,7 @@
 #include "utils_cmds.h"
 
 cmd_status_t cmd_parse_putval (size_t argc, char **argv,
-               cmd_putval_t *ret_cmd, cmd_error_handler_t *err);
+               cmd_putval_t *ret_putval, cmd_error_handler_t *err);
 
 cmd_status_t cmd_handle_putval (FILE *fh, char *buffer);
 

diff --git a/src/utils_cmds.c b/src/utils_cmds.c
index 3bc260b..f5494a4 100644 (file)
--- a/src/utils_cmds.c
+++ b/src/utils_cmds.c
@@ -27,6 +27,7 @@
  **/
 
 #include "utils_cmds.h"
+#include "utils_cmd_flush.h"
 #include "utils_cmd_putval.h"
 #include "utils_parse_option.h"
 #include "daemon/common.h"
@@ -206,7 +207,13 @@ cmd_status_t cmd_parsev (size_t argc, char **argv,
 
        memset (ret_cmd, 0, sizeof (*ret_cmd));
        command = argv[0];
-       if (strcasecmp ("PUTVAL", command) == 0)
+       if (strcasecmp ("FLUSH", command) == 0)
+       {
+               ret_cmd->type = CMD_FLUSH;
+               return cmd_parse_flush (argc - 1, argv + 1,
+                               &ret_cmd->cmd.flush, err);
+       }
+       else if (strcasecmp ("PUTVAL", command) == 0)
        {
                ret_cmd->type = CMD_PUTVAL;
                return cmd_parse_putval (argc - 1, argv + 1,
@@ -248,6 +255,9 @@ void cmd_destroy (cmd_t *cmd)
                case CMD_UNKNOWN:
                        /* nothing to do */
                        break;
+               case CMD_FLUSH:
+                       cmd_destroy_flush (&cmd->cmd.flush);
+                       break;
                case CMD_PUTVAL:
                        cmd_destroy_putval (&cmd->cmd.putval);
                        break;

diff --git a/src/utils_cmds.h b/src/utils_cmds.h
index 7dc80fa..21564cb 100644 (file)
--- a/src/utils_cmds.h
+++ b/src/utils_cmds.h
@@ -33,13 +33,24 @@
 
 typedef enum {
        CMD_UNKNOWN = 0,
-       CMD_PUTVAL  = 1,
+       CMD_FLUSH   = 1,
+       CMD_PUTVAL  = 2,
 } cmd_type_t;
 #define CMD_TO_STRING(type) \
-       ((type) == CMD_PUTVAL) ? "PUTVAL" \
+       ((type) == CMD_FLUSH) ? "FLUSH" \
+               : ((type) == CMD_PUTVAL) ? "PUTVAL" \
                : "UNKNOWN"
 
 typedef struct {
+       double timeout;
+
+       char **plugins;
+       size_t plugins_num;
+       identifier_t *identifiers;
+       size_t identifiers_num;
+} cmd_flush_t;
+
+typedef struct {
        /* The raw identifier as provided by the user. */
        char *identifier;
 
@@ -59,6 +70,7 @@ typedef struct {
 typedef struct {
        cmd_type_t type;
        union {
+               cmd_flush_t flush;
                cmd_putval_t putval;
        } cmd;
 } cmd_t;