LCOV - code coverage report
Current view: top level - src/plugins/tracer - tracer.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 41 58 70.7 %
Date: 2019-09-12 12:28:41 Functions: 5 7 71.4 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  */
       8             : 
       9             : #ifndef HAVE_KDBCONFIG
      10             : #include "kdbconfig.h"
      11             : #endif
      12             : 
      13             : #include "tracer.h"
      14             : 
      15             : #include <string.h>
      16             : 
      17          45 : int elektraTracerOpen (Plugin * handle, Key * errorKey)
      18             : {
      19          45 :         ssize_t nr_keys = 0;
      20          45 :         KeySet * config = elektraPluginGetConfig (handle);
      21             : 
      22          45 :         if (ksLookupByName (config, "/module", 0))
      23             :         {
      24          19 :                 if (ksLookupByName (config, "/logmodule", 0))
      25             :                 {
      26             :                         Key * k;
      27           0 :                         printf ("tracer: openmodule(%p, %s = %s): ", (void *) handle, keyName (errorKey), keyString (errorKey));
      28           0 :                         while ((k = ksNext (config)) != 0)
      29             :                         {
      30           0 :                                 printf ("%s=%s ", keyName (k), keyString (k));
      31           0 :                                 ++nr_keys;
      32             :                         }
      33           0 :                         printf ("%zd\n", nr_keys);
      34             :                 }
      35             :         }
      36             :         else
      37             :         {
      38             :                 Key * k;
      39          26 :                 printf ("tracer: open(%p, %s = %s): ", (void *) handle, keyName (errorKey), keyString (errorKey));
      40          52 :                 while ((k = ksNext (config)) != 0)
      41             :                 {
      42           0 :                         printf ("%s=%s ", keyName (k), keyString (k));
      43           0 :                         ++nr_keys;
      44             :                 }
      45          26 :                 printf ("%zd\n", nr_keys);
      46             :         }
      47             : 
      48             : 
      49          45 :         return 0;
      50             : }
      51             : 
      52          45 : int elektraTracerClose (Plugin * handle, Key * errorKey)
      53             : {
      54          45 :         KeySet * config = elektraPluginGetConfig (handle);
      55             : 
      56          45 :         if (ksLookupByName (config, "/module", 0))
      57             :         {
      58          19 :                 if (ksLookupByName (config, "/logmodule", 0))
      59             :                 {
      60           0 :                         printf ("tracer: closemodule(%p, %s = %s)\n", (void *) handle, keyName (errorKey), keyString (errorKey));
      61             :                 }
      62             :         }
      63             :         else
      64             :         {
      65          26 :                 printf ("tracer: close(%p, %s = %s)\n", (void *) handle, keyName (errorKey), keyString (errorKey));
      66             :         }
      67             : 
      68          45 :         return 0;
      69             : }
      70             : 
      71          59 : int elektraTracerGet (Plugin * handle, KeySet * returned, Key * parentKey)
      72             : {
      73          59 :         ssize_t nr_keys = 0;
      74          59 :         Key * k = 0;
      75             : 
      76          59 :         if (!strcmp (keyName (parentKey), "system/elektra/modules/tracer"))
      77             :         {
      78          43 :                 KeySet * info =
      79          43 :                         ksNew (50, keyNew ("system/elektra/modules/tracer", KEY_VALUE, "tracer plugin waits for your orders", KEY_END),
      80             :                                keyNew ("system/elektra/modules/tracer/exports", KEY_END),
      81             :                                keyNew ("system/elektra/modules/tracer/exports/open", KEY_FUNC, elektraTracerOpen, KEY_END),
      82             :                                keyNew ("system/elektra/modules/tracer/exports/close", KEY_FUNC, elektraTracerClose, KEY_END),
      83             :                                keyNew ("system/elektra/modules/tracer/exports/get", KEY_FUNC, elektraTracerGet, KEY_END),
      84             :                                keyNew ("system/elektra/modules/tracer/exports/set", KEY_FUNC, elektraTracerSet, KEY_END),
      85             :                                keyNew ("system/elektra/modules/tracer/exports/error", KEY_FUNC, elektraTracerError, KEY_END),
      86             : #include "readme_tracer.c"
      87             :                                keyNew ("system/elektra/modules/tracer/infos/version", KEY_VALUE, PLUGINVERSION, KEY_END), KS_END);
      88          43 :                 ksAppend (returned, info);
      89          43 :                 ksDel (info);
      90          43 :                 return 1;
      91             :         }
      92             : 
      93          16 :         printf ("tracer: get(%p, %s, %s): ", (void *) handle, keyName (parentKey), keyString (parentKey));
      94          38 :         while ((k = ksNext (returned)) != 0)
      95             :         {
      96           6 :                 printf ("%s ", keyName (k));
      97           6 :                 ++nr_keys;
      98             :         }
      99          16 :         printf ("%zd\n", nr_keys);
     100             : 
     101          16 :         return nr_keys;
     102             : }
     103             : 
     104           3 : int elektraTracerSet (Plugin * handle, KeySet * returned, Key * parentKey)
     105             : {
     106           3 :         ssize_t nr_keys = 0;
     107           3 :         Key * k = 0;
     108             : 
     109           3 :         printf ("tracer: set(%p, %s, %s): ", (void *) handle, keyName (parentKey), keyString (parentKey));
     110          26 :         while ((k = ksNext (returned)) != 0)
     111             :         {
     112          20 :                 printf ("%s ", keyName (k));
     113          20 :                 ++nr_keys;
     114             :         }
     115           3 :         printf ("%zd\n", nr_keys);
     116             : 
     117           3 :         return nr_keys;
     118             : }
     119             : 
     120           0 : int elektraTracerError (Plugin * handle, KeySet * returned, Key * parentKey)
     121             : {
     122           0 :         ssize_t nr_keys = 0;
     123           0 :         Key * k = 0;
     124             : 
     125           0 :         printf ("tracer: error(%p, %s, %s): ", (void *) handle, keyName (parentKey), keyString (parentKey));
     126           0 :         while ((k = ksNext (returned)) != 0)
     127             :         {
     128           0 :                 printf ("%s ", keyName (k));
     129           0 :                 ++nr_keys;
     130             :         }
     131           0 :         printf ("%zd\n", nr_keys);
     132             : 
     133           0 :         return nr_keys;
     134             : }
     135             : 
     136          45 : Plugin * ELEKTRA_PLUGIN_EXPORT
     137             : {
     138             :         // clang-format off
     139          45 :         return elektraPluginExport("tracer",
     140             :                 ELEKTRA_PLUGIN_OPEN,    &elektraTracerOpen,
     141             :                 ELEKTRA_PLUGIN_CLOSE,   &elektraTracerClose,
     142             :                 ELEKTRA_PLUGIN_GET,     &elektraTracerGet,
     143             :                 ELEKTRA_PLUGIN_SET,     &elektraTracerSet,
     144             :                 ELEKTRA_PLUGIN_ERROR,   &elektraTracerError,
     145             :                 ELEKTRA_PLUGIN_END);
     146             : }
     147             : 

Generated by: LCOV version 1.13