Merge branch 'collectd-5.5' into collectd-5.6
[collectd.git] / src / gps.c
1 /**
2  * collectd - src/gps.c
3  * Copyright (C) 2015  Nicolas JOURDEN
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a
6  * copy of this software and associated documentation files (the "Software"),
7  * to deal in the Software without restriction, including without limitation
8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9  * and/or sell copies of the Software, and to permit persons to whom the
10  * Software is furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21  * DEALINGS IN THE SOFTWARE.
22  *
23  * Authors:
24  *   Nicolas JOURDEN <nicolas.jourden at laposte.net>
25  *   Florian octo Forster <octo at collectd.org>
26  *   Marc Fournier <marc.fournier at camptocamp.com>
27  **/
28
29 #include "collectd.h"
30 #include "common.h"
31 #include "plugin.h"
32 #include "utils_time.h"
33
34 #define CGPS_TRUE                  1
35 #define CGPS_FALSE                 0
36 #define CGPS_DEFAULT_HOST          "localhost"
37 #define CGPS_DEFAULT_PORT          "2947" /* DEFAULT_GPSD_PORT */
38 #define CGPS_DEFAULT_TIMEOUT       MS_TO_CDTIME_T (15)
39 #define CGPS_DEFAULT_PAUSE_CONNECT TIME_T_TO_CDTIME_T (5)
40 #define CGPS_MAX_ERROR             100
41 #define CGPS_CONFIG                "?WATCH={\"enable\":true,\"json\":true,\"nmea\":false}\r\n"
42
43 #include <gps.h>
44 #include <pthread.h>
45
46 typedef struct {
47   char *host;
48   char *port;
49   cdtime_t timeout;
50   cdtime_t pause_connect;
51 } cgps_config_t;
52
53 typedef struct {
54   gauge_t sats_used;
55   gauge_t sats_visible;
56   gauge_t hdop;
57   gauge_t vdop;
58 } cgps_data_t;
59
60 static cgps_config_t cgps_config_data;
61
62 static cgps_data_t cgps_data = {NAN, NAN, NAN, NAN};
63
64 static pthread_t cgps_thread_id;
65 static pthread_mutex_t  cgps_data_lock = PTHREAD_MUTEX_INITIALIZER;
66 static pthread_mutex_t  cgps_thread_lock = PTHREAD_MUTEX_INITIALIZER;
67 static int cgps_thread_shutdown = CGPS_FALSE;
68 static int cgps_thread_running = CGPS_FALSE;
69
70 /**
71  * Non blocking pause for the thread.
72  */
73 static int cgps_thread_pause(cdtime_t pTime)
74 {
75   cdtime_t now;
76   now = cdtime ();
77   struct timespec pause_th;
78   CDTIME_T_TO_TIMESPEC (MS_TO_CDTIME_T(10), &pause_th);
79   while (CGPS_TRUE)
80   {
81     if ( (cdtime () - now) > pTime )
82     {
83       break;
84     }
85
86     pthread_mutex_lock (&cgps_thread_lock);
87     if (cgps_thread_shutdown == CGPS_TRUE)
88     {
89       return CGPS_FALSE;
90     }
91     pthread_mutex_unlock (&cgps_thread_lock);
92     nanosleep (&pause_th, NULL);
93  }
94
95  return CGPS_TRUE;
96 }
97
98 /**
99  * Thread reading from gpsd.
100  */
101 static void * cgps_thread (void * pData)
102 {
103   struct gps_data_t gpsd_conn;
104   unsigned int err_count;
105   cgps_thread_running = CGPS_TRUE;
106
107   while (CGPS_TRUE)
108   {
109     pthread_mutex_lock (&cgps_thread_lock);
110     if (cgps_thread_shutdown == CGPS_TRUE)
111     {
112       goto quit;
113     }
114     pthread_mutex_unlock (&cgps_thread_lock);
115
116     err_count = 0;
117
118 #if GPSD_API_MAJOR_VERSION > 4
119     int status = gps_open (cgps_config_data.host, cgps_config_data.port, &gpsd_conn);
120 #else
121     int status = gps_open_r (cgps_config_data.host, cgps_config_data.port, &gpsd_conn);
122 #endif
123     if (status < 0)
124     {
125       WARNING ("gps plugin: connecting to %s:%s failed: %s",
126                cgps_config_data.host, cgps_config_data.port, gps_errstr (status));
127
128       // Here we make a pause until a new tentative to connect, we check also if
129       // the thread does not need to stop.
130       if (cgps_thread_pause(cgps_config_data.pause_connect) == CGPS_FALSE)
131       {
132         goto quit;
133       }
134
135       continue;
136     }
137
138     gps_stream (&gpsd_conn, WATCH_ENABLE | WATCH_JSON | WATCH_NEWSTYLE, NULL);
139     gps_send (&gpsd_conn, CGPS_CONFIG);
140
141     while (CGPS_TRUE)
142     {
143       pthread_mutex_lock (&cgps_thread_lock);
144       if (cgps_thread_shutdown == CGPS_TRUE)
145       {
146         goto stop;
147       }
148       pthread_mutex_unlock (&cgps_thread_lock);
149
150 #if GPSD_API_MAJOR_VERSION > 4
151       long timeout_us = CDTIME_T_TO_US (cgps_config_data.timeout);
152       if (!gps_waiting (&gpsd_conn, (int) timeout_us ))
153 #else
154       if (!gps_waiting (&gpsd_conn))
155 #endif
156       {
157         continue;
158       }
159
160       if (gps_read (&gpsd_conn) == -1)
161       {
162         WARNING ("gps plugin: incorrect data! (err_count: %d)", err_count);
163         err_count++;
164
165         if (err_count > CGPS_MAX_ERROR)
166         {
167           // Server is not responding ...
168           if (gps_send (&gpsd_conn, CGPS_CONFIG) == -1)
169           {
170             WARNING ("gps plugin: gpsd seems to be down, reconnecting");
171             gps_close (&gpsd_conn);
172             break;
173           }
174           // Server is responding ...
175           else
176           {
177             err_count = 0;
178           }
179         }
180
181         continue;
182       }
183
184       pthread_mutex_lock (&cgps_data_lock);
185
186       // Number of sats in view:
187       cgps_data.sats_used = (gauge_t) gpsd_conn.satellites_used;
188       cgps_data.sats_visible = (gauge_t) gpsd_conn.satellites_visible;
189
190       // dilution of precision:
191       cgps_data.vdop = NAN;
192       cgps_data.hdop = NAN;
193       if (cgps_data.sats_used > 0)
194       {
195         cgps_data.hdop = gpsd_conn.dop.hdop;
196         cgps_data.vdop = gpsd_conn.dop.vdop;
197       }
198
199       DEBUG ("gps plugin: %.0f sats used (of %.0f visible), hdop = %.3f, vdop = %.3f",
200              cgps_data.sats_used, cgps_data.sats_visible, cgps_data.hdop, cgps_data.vdop);
201
202       pthread_mutex_unlock (&cgps_data_lock);
203     }
204   }
205
206 stop:
207   DEBUG ("gps plugin: thread closing gpsd connection ... ");
208   gps_stream (&gpsd_conn, WATCH_DISABLE, NULL);
209   gps_close (&gpsd_conn);
210 quit:
211   DEBUG ("gps plugin: thread shutting down ... ");
212   cgps_thread_running = CGPS_FALSE;
213   pthread_mutex_unlock (&cgps_thread_lock);
214   pthread_exit (NULL);
215 }
216
217
218 /**
219  * Submit a piece of the data.
220  */
221 static void cgps_submit (const char *type, gauge_t value, const char *type_instance)
222 {
223   value_t values[1];
224   value_list_t vl = VALUE_LIST_INIT;
225
226   values[0].gauge = value;
227
228   vl.values = values;
229   vl.values_len = 1;
230   sstrncpy (vl.host, hostname_g, sizeof (vl.host));
231   sstrncpy (vl.plugin, "gps", sizeof (vl.plugin));
232   sstrncpy (vl.type, type, sizeof (vl.type));
233   sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
234
235   plugin_dispatch_values (&vl);
236 }
237
238 /**
239  * Read the data and submit by piece.
240  */
241 static int cgps_read (void)
242 {
243   cgps_data_t data_copy;
244
245   pthread_mutex_lock (&cgps_data_lock);
246   data_copy = cgps_data;
247   pthread_mutex_unlock (&cgps_data_lock);
248
249   cgps_submit ("dilution_of_precision", data_copy.hdop, "horizontal");
250   cgps_submit ("dilution_of_precision", data_copy.vdop, "vertical");
251   cgps_submit ("satellites", data_copy.sats_used, "used");
252   cgps_submit ("satellites", data_copy.sats_visible, "visible");
253
254   return (0);
255 }
256
257 /**
258  * Read configuration.
259  */
260 static int cgps_config (oconfig_item_t *ci)
261 {
262   int i;
263
264   for (i = 0; i < ci->children_num; i++)
265   {
266     oconfig_item_t *child = ci->children + i;
267
268     if (strcasecmp ("Host", child->key) == 0)
269       cf_util_get_string (child, &cgps_config_data.host);
270     else if (strcasecmp ("Port", child->key) == 0)
271       cf_util_get_service (child, &cgps_config_data.port);
272     else if (strcasecmp ("Timeout", child->key) == 0)
273       cf_util_get_cdtime (child, &cgps_config_data.timeout);
274     else if (strcasecmp ("PauseConnect", child->key) == 0)
275       cf_util_get_cdtime (child, &cgps_config_data.pause_connect);
276     else
277       WARNING ("gps plugin: Ignoring unknown config option \"%s\".", child->key);
278   }
279
280   // Controlling the value for timeout:
281   // If set too high it blocks the reading (> 5 s), too low it gets not reading (< 500 us).
282   // To avoid any issues we replace "out of range" value by the default value.
283   if (
284     cgps_config_data.timeout > TIME_T_TO_CDTIME_T(5)
285     ||
286     cgps_config_data.timeout < US_TO_CDTIME_T(500)
287   )
288   {
289     WARNING ("gps plugin: timeout set to %.6f sec. setting to default (%.6f).",
290       CDTIME_T_TO_DOUBLE(cgps_config_data.timeout),
291       CDTIME_T_TO_DOUBLE(CGPS_DEFAULT_TIMEOUT)
292     );
293     cgps_config_data.timeout = CGPS_DEFAULT_TIMEOUT;
294   }
295
296   return (0);
297 }
298
299 /**
300  * Init.
301  */
302 static int cgps_init (void)
303 {
304   int status;
305
306   if (cgps_thread_running == CGPS_TRUE)
307   {
308     DEBUG ("gps plugin: error gps thread already running ... ");
309     return 0;
310   }
311
312   DEBUG ("gps plugin: config{host: \"%s\", port: \"%s\", timeout: %.6f sec., pause connect: %.3f sec.}",
313          cgps_config_data.host, cgps_config_data.port,
314          CDTIME_T_TO_DOUBLE (cgps_config_data.timeout),
315          CDTIME_T_TO_DOUBLE (cgps_config_data.pause_connect));
316
317   status = plugin_thread_create (&cgps_thread_id, NULL, cgps_thread, NULL);
318   if (status != 0)
319   {
320     ERROR ("gps plugin: pthread_create() failed.");
321     return (-1);
322   }
323
324   return (0);
325 }
326
327 /**
328  * Shutdown.
329  */
330 static int cgps_shutdown (void)
331 {
332   void * res;
333
334   pthread_mutex_lock (&cgps_thread_lock);
335   cgps_thread_shutdown = CGPS_TRUE;
336   pthread_mutex_unlock (&cgps_thread_lock);
337
338   pthread_join(cgps_thread_id, &res);
339   free(res);
340
341   // Clean mutex:
342   pthread_mutex_unlock(&cgps_thread_lock);
343   pthread_mutex_destroy(&cgps_thread_lock);
344   pthread_mutex_unlock(&cgps_data_lock);
345   pthread_mutex_destroy(&cgps_data_lock);
346
347   sfree (cgps_config_data.port);
348   sfree (cgps_config_data.host);
349
350   return (0);
351 }
352
353 /**
354  * Register the module.
355  */
356 void module_register (void)
357 {
358   cgps_config_data.host = sstrdup (CGPS_DEFAULT_HOST);
359   cgps_config_data.port = sstrdup (CGPS_DEFAULT_PORT);
360   cgps_config_data.timeout = CGPS_DEFAULT_TIMEOUT;
361   cgps_config_data.pause_connect = CGPS_DEFAULT_PAUSE_CONNECT;
362
363   plugin_register_complex_config ("gps", cgps_config);
364   plugin_register_init ("gps", cgps_init);
365   plugin_register_read ("gps", cgps_read);
366   plugin_register_shutdown ("gps", cgps_shutdown);
367 }