LCOV - code coverage report
Current view: top level - src/plugins/logchange - logchange.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 12 48 25.0 %
Date: 2019-09-12 12:28:41 Functions: 3 6 50.0 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief Source for logchange plugin
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  *
       8             :  */
       9             : 
      10             : 
      11             : #ifndef HAVE_KDBCONFIG
      12             : #include "kdbconfig.h"
      13             : #endif
      14             : 
      15             : #include <stdio.h>
      16             : #include <string.h>
      17             : 
      18             : #include "logchange.h"
      19             : 
      20           0 : static void logKeys (KeySet * ks, const char * message)
      21             : {
      22           0 :         ksRewind (ks);
      23           0 :         Key * k = 0;
      24           0 :         while ((k = ksNext (ks)) != 0)
      25             :         {
      26           0 :                 printf ("%s: %s\n", message, keyName (k));
      27             :         }
      28           0 : }
      29             : 
      30          20 : int elektraLogchangeGet (Plugin * handle, KeySet * returned, Key * parentKey ELEKTRA_UNUSED)
      31             : {
      32          20 :         if (!strcmp (keyName (parentKey), "system/elektra/modules/logchange"))
      33             :         {
      34          20 :                 KeySet * contract = ksNew (
      35             :                         30, keyNew ("system/elektra/modules/logchange", KEY_VALUE, "logchange plugin waits for your orders", KEY_END),
      36             :                         keyNew ("system/elektra/modules/logchange/exports", KEY_END),
      37             :                         keyNew ("system/elektra/modules/logchange/exports/get", KEY_FUNC, elektraLogchangeGet, KEY_END),
      38             :                         keyNew ("system/elektra/modules/logchange/exports/set", KEY_FUNC, elektraLogchangeSet, KEY_END),
      39             :                         keyNew ("system/elektra/modules/logchange/exports/close", KEY_FUNC, elektraLogchangeClose, KEY_END),
      40             : #include ELEKTRA_README
      41             :                         keyNew ("system/elektra/modules/logchange/infos/version", KEY_VALUE, PLUGINVERSION, KEY_END), KS_END);
      42          20 :                 ksAppend (returned, contract);
      43          20 :                 ksDel (contract);
      44             : 
      45          20 :                 return 1; /* success */
      46             :         }
      47             : 
      48             :         // remember all keys
      49           0 :         KeySet * ks = (KeySet *) elektraPluginGetData (handle);
      50           0 :         if (ks) ksDel (ks);
      51           0 :         elektraPluginSetData (handle, ksDup (returned));
      52             : 
      53           0 :         if (strncmp (keyString (ksLookupByName (elektraPluginGetConfig (handle), "/log/get", 0)), "1", 1) == 0)
      54             :         {
      55           0 :                 KeySet * logset = ksNew (1, keyDup (parentKey), KS_END);
      56           0 :                 logKeys (logset, "loading configuration");
      57           0 :                 ksDel (logset);
      58             :         }
      59             : 
      60             :         return 1; /* success */
      61             : }
      62             : 
      63           0 : int elektraLogchangeSet (Plugin * handle, KeySet * returned, Key * parentKey ELEKTRA_UNUSED)
      64             : {
      65           0 :         KeySet * oldKeys = (KeySet *) elektraPluginGetData (handle);
      66             :         // because elektraLogchangeGet will always be executed before elektraLogchangeSet
      67             :         // we know that oldKeys must exist here!
      68           0 :         ksRewind (oldKeys);
      69           0 :         ksRewind (returned);
      70             : 
      71           0 :         KeySet * addedKeys = ksDup (returned);
      72           0 :         KeySet * changedKeys = ksNew (0, KS_END);
      73           0 :         KeySet * removedKeys = ksNew (0, KS_END);
      74             : 
      75           0 :         Key * k = 0;
      76           0 :         while ((k = ksNext (oldKeys)) != 0)
      77             :         {
      78           0 :                 Key * p = ksLookup (addedKeys, k, KDB_O_POP);
      79             :                 // Note: keyDel not needed, because at least two references exist
      80           0 :                 if (p)
      81             :                 {
      82           0 :                         if (keyNeedSync (p))
      83             :                         {
      84           0 :                                 ksAppendKey (changedKeys, p);
      85             :                         }
      86             :                 }
      87             :                 else
      88             :                 {
      89           0 :                         ksAppendKey (removedKeys, k);
      90             :                 }
      91             :         }
      92             : 
      93           0 :         logKeys (addedKeys, "added key");
      94           0 :         logKeys (changedKeys, "changed key");
      95           0 :         logKeys (removedKeys, "removed key");
      96             : 
      97           0 :         ksDel (oldKeys);
      98           0 :         ksDel (addedKeys);
      99           0 :         ksDel (changedKeys);
     100           0 :         ksDel (removedKeys);
     101             : 
     102             :         // for next invocation of elektraLogchangeSet, remember our current keyset
     103           0 :         elektraPluginSetData (handle, ksDup (returned));
     104             : 
     105           0 :         return 1; /* success */
     106             : }
     107             : 
     108          20 : int elektraLogchangeClose (Plugin * handle, Key * parentKey ELEKTRA_UNUSED)
     109             : {
     110          20 :         KeySet * ks = (KeySet *) elektraPluginGetData (handle);
     111          20 :         if (ks) ksDel (ks);
     112          20 :         return 1; /* success */
     113             : }
     114             : 
     115          20 : Plugin * ELEKTRA_PLUGIN_EXPORT
     116             : {
     117             :         // clang-format off
     118          20 :         return elektraPluginExport("logchange",
     119             :                 ELEKTRA_PLUGIN_GET,     &elektraLogchangeGet,
     120             :                 ELEKTRA_PLUGIN_SET,     &elektraLogchangeSet,
     121             :                 ELEKTRA_PLUGIN_CLOSE,   &elektraLogchangeClose,
     122             :                 ELEKTRA_PLUGIN_END);
     123             : }

Generated by: LCOV version 1.13