csv plugin: Add a `DataDir' option.
[collectd.git] / src / csv.c
1 /**
2  * collectd - src/csv.c
3  * Copyright (C) 2007  Florian octo Forster
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License as published by the
7  * Free Software Foundation; only version 2 of the License is applicable.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with this program; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
17  *
18  * Authors:
19  *   Florian octo Forster <octo at verplant.org>
20  **/
21
22 #include "collectd.h"
23 #include "plugin.h"
24 #include "common.h"
25 #include "utils_debug.h"
26
27 /*
28  * Private variables
29  */
30 static const char *config_keys[] =
31 {
32         "DataDir"
33 };
34 static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
35
36 static char *datadir   = NULL;
37
38 static int value_list_to_string (char *buffer, int buffer_len,
39                 const data_set_t *ds, const value_list_t *vl)
40 {
41         int offset;
42         int status;
43         int i;
44
45         memset (buffer, '\0', sizeof (buffer_len));
46
47         status = snprintf (buffer, buffer_len, "%u", (unsigned int) vl->time);
48         if ((status < 1) || (status >= buffer_len))
49                 return (-1);
50         offset = status;
51
52         for (i = 0; i < ds->ds_num; i++)
53         {
54                 if ((ds->ds[i].type != DS_TYPE_COUNTER)
55                                 && (ds->ds[i].type != DS_TYPE_GAUGE))
56                         return (-1);
57
58                 if (ds->ds[i].type == DS_TYPE_COUNTER)
59                         status = snprintf (buffer + offset, buffer_len - offset,
60                                         ",%llu", vl->values[i].counter);
61                 else
62                         status = snprintf (buffer + offset, buffer_len - offset,
63                                         ",%lf", vl->values[i].gauge);
64
65                 if ((status < 1) || (status >= (buffer_len - offset)))
66                         return (-1);
67
68                 offset += status;
69         } /* for ds->ds_num */
70
71         return (0);
72 } /* int value_list_to_string */
73
74 static int value_list_to_filename (char *buffer, int buffer_len,
75                 const data_set_t *ds, const value_list_t *vl)
76 {
77         int offset = 0;
78         int status;
79
80         if (datadir != NULL)
81         {
82                 status = snprintf (buffer + offset, buffer_len - offset,
83                                 "%s/", datadir);
84                 if ((status < 1) || (status >= buffer_len - offset))
85                         return (-1);
86                 offset += status;
87         }
88
89         status = snprintf (buffer + offset, buffer_len - offset,
90                         "%s/", vl->host);
91         if ((status < 1) || (status >= buffer_len - offset))
92                 return (-1);
93         offset += status;
94
95         if (strlen (vl->plugin_instance) > 0)
96                 status = snprintf (buffer + offset, buffer_len - offset,
97                                 "%s-%s/", vl->plugin, vl->plugin_instance);
98         else
99                 status = snprintf (buffer + offset, buffer_len - offset,
100                                 "%s/", vl->plugin);
101         if ((status < 1) || (status >= buffer_len - offset))
102                 return (-1);
103         offset += status;
104
105         if (strlen (vl->type_instance) > 0)
106                 status = snprintf (buffer + offset, buffer_len - offset,
107                                 "%s-%s", ds->type, vl->type_instance);
108         else
109                 status = snprintf (buffer + offset, buffer_len - offset,
110                                 "%s", ds->type);
111         if ((status < 1) || (status >= buffer_len - offset))
112                 return (-1);
113         offset += status;
114
115         {
116                 time_t now;
117                 struct tm *tm;
118
119                 /* TODO: Find a way to minimize the calls to `localtime', since
120                  * they are pretty expensive.. */
121                 now = time (NULL);
122                 tm = localtime (&now);
123
124                 strftime (buffer + offset, buffer_len - offset,
125                                 "-%Y-%m-%d", tm);
126
127                 /* `localtime(3)' returns a pointer to static data,
128                  * therefore the pointer may not be free'd. */
129         }
130
131         return (0);
132 } /* int value_list_to_filename */
133
134 static int csv_create_file (const char *filename, const data_set_t *ds)
135 {
136         FILE *csv;
137         int i;
138
139         if (check_create_dir (filename))
140                 return (-1);
141
142         csv = fopen (filename, "w");
143         if (csv == NULL)
144         {
145                 syslog (LOG_ERR, "csv plugin: fopen (%s) failed: %s",
146                                 filename, strerror(errno));
147                 return (-1);
148         }
149
150         fprintf (csv, "epoch");
151         for (i = 0; i < ds->ds_num; i++)
152                 fprintf (csv, ",%s", ds->ds[i].name);
153
154         fprintf (csv, "\n");
155         fclose (csv);
156
157         return 0;
158 } /* int csv_create_file */
159
160 static int csv_config (const char *key, const char *value)
161 {
162         if (strcasecmp ("DataDir", key) == 0)
163         {
164                 if (datadir != NULL)
165                         free (datadir);
166                 datadir = strdup (value);
167                 if (datadir != NULL)
168                 {
169                         int len = strlen (datadir);
170                         while ((len > 0) && (datadir[len - 1] == '/'))
171                         {
172                                 len--;
173                                 datadir[len] = '\0';
174                         }
175                         if (len <= 0)
176                         {
177                                 free (datadir);
178                                 datadir = NULL;
179                         }
180                 }
181         }
182         else
183         {
184                 return (-1);
185         }
186         return (0);
187 } /* int csv_config */
188
189 static int csv_write (const data_set_t *ds, const value_list_t *vl)
190 {
191         struct stat  statbuf;
192         char         filename[512];
193         char         values[512];
194         FILE        *csv;
195         int          csv_fd;
196         struct flock fl;
197         int          status;
198
199         if (value_list_to_filename (filename, sizeof (filename), ds, vl) != 0)
200                 return (-1);
201
202         DBG ("filename = %s;", filename);
203
204         if (value_list_to_string (values, sizeof (values), ds, vl) != 0)
205                 return (-1);
206
207         if (stat (filename, &statbuf) == -1)
208         {
209                 if (errno == ENOENT)
210                 {
211                         if (csv_create_file (filename, ds))
212                                 return (-1);
213                 }
214                 else
215                 {
216                         syslog (LOG_ERR, "stat(%s) failed: %s",
217                                         filename, strerror (errno));
218                         return (-1);
219                 }
220         }
221         else if (!S_ISREG (statbuf.st_mode))
222         {
223                 syslog (LOG_ERR, "stat(%s): Not a regular file!",
224                                 filename);
225                 return (-1);
226         }
227
228         csv = fopen (filename, "a");
229         if (csv == NULL)
230         {
231                 syslog (LOG_ERR, "csv plugin: fopen (%s) failed: %s",
232                                 filename, strerror (errno));
233                 return (-1);
234         }
235         csv_fd = fileno (csv);
236
237         memset (&fl, '\0', sizeof (fl));
238         fl.l_start  = 0;
239         fl.l_len    = 0; /* till end of file */
240         fl.l_pid    = getpid ();
241         fl.l_type   = F_WRLCK;
242         fl.l_whence = SEEK_SET;
243
244         status = fcntl (csv_fd, F_SETLK, &fl);
245         if (status != 0)
246         {
247                 syslog (LOG_ERR, "csv plugin: flock (%s) failed: %s",
248                                 filename, strerror (errno));
249                 fclose (csv);
250                 return (-1);
251         }
252
253         fprintf (csv, "%s\n", values);
254
255         /* The lock is implicitely released. I we don't release it explicitely
256          * because the `FILE *' may need to flush a cache first */
257         fclose (csv);
258
259         return (0);
260 } /* int csv_write */
261
262 void module_register (void)
263 {
264         plugin_register_config ("csv", csv_config,
265                         config_keys, config_keys_num);
266         plugin_register_write ("csv", csv_write);
267 }