src/daemon/plugin_mock.c

   1 /**
   2  * collectd - src/tests/mock/plugin.c
   3  * Copyright (C) 2013       Florian octo Forster
   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  *   Florian octo Forster <octo at collectd.org>
  25  */
  26
  27 #include "plugin.h"
  28
  29 #if HAVE_KSTAT_H
  30 #include <kstat.h>
  31 #endif
  32
  33 #if HAVE_LIBKSTAT
  34 kstat_ctl_t *kc = NULL;
  35 #endif /* HAVE_LIBKSTAT */
  36
  37 char *hostname_g = "example.com";
  38
  39 void plugin_set_dir(const char *dir) { /* nop */
  40 }
  41
  42 int plugin_load(const char *name, bool global) { return ENOTSUP; }
  43
  44 int plugin_register_config(const char *name,
  45                            int (*callback)(const char *key, const char *val),
  46                            const char **keys, int keys_num) {
  47   return ENOTSUP;
  48 }
  49
  50 int plugin_register_complex_config(const char *type,
  51                                    int (*callback)(oconfig_item_t *)) {
  52   return ENOTSUP;
  53 }
  54
  55 int plugin_register_init(const char *name, plugin_init_cb callback) {
  56   return ENOTSUP;
  57 }
  58
  59 int plugin_register_read(__attribute__((unused)) const char *name,
  60                          __attribute__((unused)) int (*callback)(void)) {
  61   return ENOTSUP;
  62 }
  63
  64 int plugin_register_write(__attribute__((unused)) const char *name,
  65                           __attribute__((unused)) plugin_write_cb callback,
  66                           __attribute__((unused)) user_data_t const *ud) {
  67   return ENOTSUP;
  68 }
  69
  70 int plugin_register_flush(__attribute__((unused)) const char *name,
  71                           __attribute__((unused)) plugin_flush_cb callback,
  72                           __attribute__((unused))
  73                           user_data_t const *user_data) {
  74   return ENOTSUP;
  75 }
  76
  77 int plugin_register_missing(const char *name, plugin_missing_cb callback,
  78                             user_data_t const *ud) {
  79   return ENOTSUP;
  80 }
  81
  82 int plugin_register_complex_read(const char *group, const char *name,
  83                                  int (*callback)(user_data_t *),
  84                                  cdtime_t interval,
  85                                  user_data_t const *user_data) {
  86   return ENOTSUP;
  87 }
  88
  89 int plugin_register_shutdown(const char *name, int (*callback)(void)) {
  90   return ENOTSUP;
  91 }
  92
  93 int plugin_register_data_set(const data_set_t *ds) { return ENOTSUP; }
  94
  95 int plugin_register_notification(__attribute__((unused)) const char *name,
  96                                  __attribute__((unused))
  97                                  plugin_notification_cb callback,
  98                                  __attribute__((unused))
  99                                  user_data_t const *user_data) {
 100   return ENOTSUP;
 101 }
 102
 103 #define DECLARE_UNREGISTER(t)                                                  \
 104   int plugin_unregister_##t(__attribute__((unused)) char const *name) {        \
 105     return ENOTSUP;                                                            \
 106   }
 107 DECLARE_UNREGISTER(config)
 108 DECLARE_UNREGISTER(complex_config)
 109 DECLARE_UNREGISTER(init)
 110 DECLARE_UNREGISTER(read)
 111 DECLARE_UNREGISTER(read_group)
 112 DECLARE_UNREGISTER(write)
 113 DECLARE_UNREGISTER(flush)
 114 DECLARE_UNREGISTER(missing)
 115 DECLARE_UNREGISTER(shutdown)
 116 DECLARE_UNREGISTER(data_set)
 117 DECLARE_UNREGISTER(log)
 118 DECLARE_UNREGISTER(notification)
 119
 120 int plugin_dispatch_values(value_list_t const *vl) { return ENOTSUP; }
 121
 122 int plugin_dispatch_notification(__attribute__((unused))
 123                                  const notification_t *notif) {
 124   return ENOTSUP;
 125 }
 126
 127 int plugin_notification_meta_add_string(__attribute__((unused))
 128                                         notification_t *n,
 129                                         __attribute__((unused))
 130                                         const char *name,
 131                                         __attribute__((unused))
 132                                         const char *value) {
 133   return ENOTSUP;
 134 }
 135
 136 int plugin_notification_meta_add_signed_int(__attribute__((unused))
 137                                             notification_t *n,
 138                                             __attribute__((unused))
 139                                             const char *name,
 140                                             __attribute__((unused))
 141                                             int64_t value) {
 142   return ENOTSUP;
 143 }
 144
 145 int plugin_notification_meta_add_unsigned_int(__attribute__((unused))
 146                                               notification_t *n,
 147                                               __attribute__((unused))
 148                                               const char *name,
 149                                               __attribute__((unused))
 150                                               uint64_t value) {
 151   return ENOTSUP;
 152 }
 153
 154 int plugin_notification_meta_add_double(__attribute__((unused))
 155                                         notification_t *n,
 156                                         __attribute__((unused))
 157                                         const char *name,
 158                                         __attribute__((unused)) double value) {
 159   return ENOTSUP;
 160 }
 161
 162 int plugin_notification_meta_add_boolean(__attribute__((unused))
 163                                          notification_t *n,
 164                                          __attribute__((unused))
 165                                          const char *name,
 166                                          __attribute__((unused)) _Bool value) {
 167   return ENOTSUP;
 168 }
 169
 170 int plugin_notification_meta_copy(__attribute__((unused)) notification_t *dst,
 171                                   __attribute__((unused))
 172                                   const notification_t *src) {
 173   return ENOTSUP;
 174 }
 175
 176 int plugin_notification_meta_free(__attribute__((unused))
 177                                   notification_meta_t *n) {
 178   return ENOTSUP;
 179 }
 180
 181 int plugin_flush(const char *plugin, cdtime_t timeout, const char *identifier) {
 182   return ENOTSUP;
 183 }
 184
 185 static data_source_t magic_ds[] = {{"value", DS_TYPE_DERIVE, 0.0, NAN}};
 186 static data_set_t magic = {"MAGIC", 1, magic_ds};
 187 const data_set_t *plugin_get_ds(const char *name) {
 188   if (strcmp(name, "MAGIC"))
 189     return NULL;
 190
 191   return &magic;
 192 }
 193
 194 void plugin_log(int level, char const *format, ...) {
 195   char buffer[1024];
 196   va_list ap;
 197
 198   va_start(ap, format);
 199   vsnprintf(buffer, sizeof(buffer), format, ap);
 200   va_end(ap);
 201
 202   printf("plugin_log (%i, \"%s\");\n", level, buffer);
 203 }
 204
 205 void daemon_log(int level, char const *format, ...) {
 206   char buffer[1024];
 207   va_list ap;
 208
 209   va_start(ap, format);
 210   vsnprintf(buffer, sizeof(buffer), format, ap);
 211   va_end(ap);
 212
 213   printf("daemon_log (%i, \"%s\");\n", level, buffer);
 214 }
 215
 216 void plugin_init_ctx(void) { /* nop */
 217 }
 218
 219 plugin_ctx_t mock_context = {
 220     .interval = TIME_T_TO_CDTIME_T_STATIC(10),
 221 };
 222
 223 plugin_ctx_t plugin_get_ctx(void) { return mock_context; }
 224
 225 plugin_ctx_t plugin_set_ctx(plugin_ctx_t ctx) {
 226   plugin_ctx_t prev = mock_context;
 227   mock_context = ctx;
 228   return prev;
 229 }
 230
 231 cdtime_t plugin_get_interval(void) { return mock_context.interval; }
 232
 233 int plugin_thread_create(__attribute__((unused)) pthread_t *thread,
 234                          __attribute__((unused)) const pthread_attr_t *attr,
 235                          __attribute__((unused)) void *(*start_routine)(void *),
 236                          __attribute__((unused)) void *arg,
 237                          __attribute__((unused)) char const *name) {
 238   return ENOTSUP;
 239 }
 240
 241 /* TODO(octo): this function is actually from filter_chain.h, but in order not
 242  * to tumble down that rabbit hole, we're declaring it here. A better solution
 243  * would be to hard-code the top-level config keys in daemon/collectd.c to avoid
 244  * having these references in daemon/configfile.c. */
 245 int fc_configure(const oconfig_item_t *ci) { return ENOTSUP; }