LCOV - code coverage report
Current view: top level - src/plugins/error - error.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 30 33 90.9 %
Date: 2019-09-12 12:28:41 Functions: 4 5 80.0 %

          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             : #include "error.h"
      10             : 
      11             : #ifndef HAVE_KDBCONFIG
      12             : #include "kdbconfig.h"
      13             : #endif
      14             : 
      15             : #include <stdlib.h>
      16             : 
      17             : // #include <stdio.h>
      18             : 
      19        3717 : int elektraErrorOpen (Plugin * handle ELEKTRA_UNUSED, Key * parentKey)
      20             : {
      21        3717 :         KeySet * conf = elektraPluginGetConfig (handle);
      22             : 
      23             :         /*
      24             :         FILE *f = fopen("error_plugin_debug.log", "a");
      25             :         fprintf (f, "HUHU %s\n", keyName(parentKey));
      26             :         ksRewind(conf);
      27             :         while (ksNext(conf)) fprintf(f, "%s\n", keyName(ksCurrent(conf)));
      28             :         fclose(f);
      29             :         */
      30             : 
      31        3717 :         if (ksLookupByName (conf, "/module", 0))
      32             :         {
      33             :                 // suppress warnings + errors if it is just a module
      34             :                 return 0;
      35             :         }
      36             : 
      37        2526 :         Key * warning = ksLookupByName (conf, "/on_open/warnings", 0);
      38        2526 :         if (warning)
      39             :         {
      40           0 :                 elektraTriggerWarnings (keyString (warning), parentKey, "from error plugin in kdbOpen");
      41             :         }
      42             : 
      43        2526 :         Key * error = ksLookupByName (conf, "/on_open/error", 0);
      44        2526 :         if (error)
      45             :         {
      46           0 :                 if (parentKey)
      47             :                 {
      48           0 :                         elektraTriggerError (keyString (error), parentKey, "from error plugin in kdbOpen");
      49             :                 }
      50             :                 return -1;
      51             :         }
      52             :         return 0;
      53             : }
      54             : 
      55         308 : int elektraErrorGet (Plugin * handle ELEKTRA_UNUSED, KeySet * returned, Key * parentKey ELEKTRA_UNUSED)
      56             : {
      57         308 :         if (!strcmp (keyName (parentKey), "system/elektra/modules/error"))
      58             :         {
      59             :                 KeySet * n;
      60         308 :                 ksAppend (returned,
      61         308 :                           n = ksNew (30, keyNew ("system/elektra/modules/error", KEY_VALUE, "error plugin waits for your orders", KEY_END),
      62             :                                      keyNew ("system/elektra/modules/error/exports", KEY_END),
      63             :                                      keyNew ("system/elektra/modules/error/exports/open", KEY_FUNC, elektraErrorOpen, KEY_END),
      64             :                                      keyNew ("system/elektra/modules/error/exports/get", KEY_FUNC, elektraErrorGet, KEY_END),
      65             :                                      keyNew ("system/elektra/modules/error/exports/set", KEY_FUNC, elektraErrorSet, KEY_END),
      66             : #include "readme_error.c"
      67             :                                      keyNew ("system/elektra/modules/error/infos/version", KEY_VALUE, PLUGINVERSION, KEY_END), KS_END));
      68         308 :                 ksDel (n);
      69             : 
      70         308 :                 ksAppend (returned, n = elektraErrorSpecification ());
      71         308 :                 ksDel (n);
      72             :         }
      73         308 :         return 1;
      74             : }
      75             : 
      76         921 : int elektraErrorSet (Plugin * handle ELEKTRA_UNUSED, KeySet * returned, Key * parentKey)
      77             : {
      78             :         Key * cur;
      79      142620 :         while ((cur = ksNext (returned)) != 0)
      80             :         {
      81      140817 :                 const Key * meta = 0;
      82             : 
      83      140817 :                 meta = keyGetMeta (cur, "trigger/warnings");
      84      140817 :                 if (meta)
      85             :                 {
      86          12 :                         elektraTriggerWarnings (keyString (meta), parentKey, "from error plugin in kdbSet");
      87             :                 }
      88             : 
      89      140817 :                 meta = keyGetMeta (cur, "trigger/error");
      90      140817 :                 if (meta)
      91             :                 {
      92          39 :                         elektraTriggerError (keyString (meta), parentKey, "from error plugin in kdbSet");
      93          39 :                         return -1; /* error */
      94             :                 }
      95      140778 :                 meta = keyGetMeta (cur, "trigger/error/nofail");
      96      140778 :                 if (meta)
      97             :                 {
      98           2 :                         elektraTriggerError (keyString (meta), parentKey, "from error plugin in kdbSet");
      99             :                 }
     100             :         }
     101             : 
     102             :         return 0;
     103             : }
     104             : 
     105        3717 : Plugin * ELEKTRA_PLUGIN_EXPORT
     106             : {
     107             :         // clang-format off
     108        3717 :         return elektraPluginExport("error",
     109             :                 ELEKTRA_PLUGIN_OPEN,    &elektraErrorOpen,
     110             :                 ELEKTRA_PLUGIN_GET,     &elektraErrorGet,
     111             :                 ELEKTRA_PLUGIN_SET,     &elektraErrorSet,
     112             :                 ELEKTRA_PLUGIN_END);
     113             : }
     114             : 

Generated by: LCOV version 1.13