check_systemd 2.0.1__tar.gz → 2.0.3__tar.gz

check_systemd-2.0.3/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE
+prune test
+prune systemd_source_code

check_systemd-2.0.3/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.1
+Name: check_systemd
+Version: 2.0.3
+Summary: Nagios / Icinga monitoring plugin to check systemd for failed units.
+Home-page: https://github.com/Josef-Friedrich/check_systemd
+Author: Josef Friedrich
+Author-email: josef@friedrich.rocks
+License: GNU LGPL v2
+Description: [![pypi.org](http://img.shields.io/pypi/v/check_systemd.svg)](https://pypi.python.org/pypi/check_systemd)
+        [![Build Status](https://travis-ci.org/Josef-Friedrich/check_systemd.svg?branch=master)](https://travis-ci.org/Josef-Friedrich/check_systemd)
+        
+        # check_systemd
+        
+        Nagios / Icinga monitoring plugin to check systemd for failed units.
+        
+        This Python script will report a degraded system to Nagios / Icinage.
+        It requires only the nagiosplugin library.
+        
+        You can also test a single service with -s parameter.
+        
+        Released under GNU GPLv2 License.
+        
+        ## Installation
+        
+        ```
+        pip3 install check_systemd
+        ```
+        
+        ## Command line interface
+        
+        ```
+        usage: nosetests [-h] [-c SECONDS] [-e UNIT | -u UNIT] [-v] [-V] [-w SECONDS]
+        
+        Nagios / Icinga monitoring plugin to check systemd for failed units.
+        
+        optional arguments:
+          -h, --help            show this help message and exit
+          -c SECONDS, --critical SECONDS
+                                Startup time in seconds to result in critical status.
+          -e UNIT, --exclude UNIT
+                                Exclude a systemd unit from the checks. This option
+                                can be applied multiple times. For example: -e mnt-
+                                data.mount -e task.service.
+          -u UNIT, --unit UNIT  Name of the systemd unit that is beeing tested.
+          -v, --verbose         Increase output verbosity (use up to 3 times).
+          -V, --version         show program's version number and exit
+          -w SECONDS, --warning SECONDS
+                                Startup time in seconds to result in warning status.
+        
+        ```
+        
+        ## Project pages
+        
+        * https://github.com/Josef-Friedrich/check_systemd
+        * https://exchange.icinga.com/joseffriedrich/check_systemd
+        
+        ## Testing
+        
+        ```
+        pip3 install tox
+        tox
+        ```
+Keywords: nagios,systemd
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Plugins
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v2 (LGPLv2)
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: System :: Networking :: Monitoring
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown

check_systemd-2.0.3/README.md

@@ -0,0 +1,54 @@
+[![pypi.org](http://img.shields.io/pypi/v/check_systemd.svg)](https://pypi.python.org/pypi/check_systemd)
+[![Build Status](https://travis-ci.org/Josef-Friedrich/check_systemd.svg?branch=master)](https://travis-ci.org/Josef-Friedrich/check_systemd)
+
+# check_systemd
+
+Nagios / Icinga monitoring plugin to check systemd for failed units.
+
+This Python script will report a degraded system to Nagios / Icinage.
+It requires only the nagiosplugin library.
+
+You can also test a single service with -s parameter.
+
+Released under GNU GPLv2 License.
+
+## Installation
+
+```
+pip3 install check_systemd
+```
+
+## Command line interface
+
+```
+usage: nosetests [-h] [-c SECONDS] [-e UNIT | -u UNIT] [-v] [-V] [-w SECONDS]
+
+Nagios / Icinga monitoring plugin to check systemd for failed units.
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -c SECONDS, --critical SECONDS
+                        Startup time in seconds to result in critical status.
+  -e UNIT, --exclude UNIT
+                        Exclude a systemd unit from the checks. This option
+                        can be applied multiple times. For example: -e mnt-
+                        data.mount -e task.service.
+  -u UNIT, --unit UNIT  Name of the systemd unit that is beeing tested.
+  -v, --verbose         Increase output verbosity (use up to 3 times).
+  -V, --version         show program's version number and exit
+  -w SECONDS, --warning SECONDS
+                        Startup time in seconds to result in warning status.
+
+```
+
+## Project pages
+
+* https://github.com/Josef-Friedrich/check_systemd
+* https://exchange.icinga.com/joseffriedrich/check_systemd
+
+## Testing
+
+```
+pip3 install tox
+tox
+```

check_systemd-2.0.3/check_systemd.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.1
+Name: check-systemd
+Version: 2.0.3
+Summary: Nagios / Icinga monitoring plugin to check systemd for failed units.
+Home-page: https://github.com/Josef-Friedrich/check_systemd
+Author: Josef Friedrich
+Author-email: josef@friedrich.rocks
+License: GNU LGPL v2
+Description: [![pypi.org](http://img.shields.io/pypi/v/check_systemd.svg)](https://pypi.python.org/pypi/check_systemd)
+        [![Build Status](https://travis-ci.org/Josef-Friedrich/check_systemd.svg?branch=master)](https://travis-ci.org/Josef-Friedrich/check_systemd)
+        
+        # check_systemd
+        
+        Nagios / Icinga monitoring plugin to check systemd for failed units.
+        
+        This Python script will report a degraded system to Nagios / Icinage.
+        It requires only the nagiosplugin library.
+        
+        You can also test a single service with -s parameter.
+        
+        Released under GNU GPLv2 License.
+        
+        ## Installation
+        
+        ```
+        pip3 install check_systemd
+        ```
+        
+        ## Command line interface
+        
+        ```
+        usage: nosetests [-h] [-c SECONDS] [-e UNIT | -u UNIT] [-v] [-V] [-w SECONDS]
+        
+        Nagios / Icinga monitoring plugin to check systemd for failed units.
+        
+        optional arguments:
+          -h, --help            show this help message and exit
+          -c SECONDS, --critical SECONDS
+                                Startup time in seconds to result in critical status.
+          -e UNIT, --exclude UNIT
+                                Exclude a systemd unit from the checks. This option
+                                can be applied multiple times. For example: -e mnt-
+                                data.mount -e task.service.
+          -u UNIT, --unit UNIT  Name of the systemd unit that is beeing tested.
+          -v, --verbose         Increase output verbosity (use up to 3 times).
+          -V, --version         show program's version number and exit
+          -w SECONDS, --warning SECONDS
+                                Startup time in seconds to result in warning status.
+        
+        ```
+        
+        ## Project pages
+        
+        * https://github.com/Josef-Friedrich/check_systemd
+        * https://exchange.icinga.com/joseffriedrich/check_systemd
+        
+        ## Testing
+        
+        ```
+        pip3 install tox
+        tox
+        ```
+Keywords: nagios,systemd
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Plugins
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v2 (LGPLv2)
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: System :: Networking :: Monitoring
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown

{check_systemd-2.0.1 → check_systemd-2.0.3}/check_systemd.egg-info/SOURCES.txt

@@ -7,7 +7,6 @@ setup.py
 check_systemd.egg-info/PKG-INFO
 check_systemd.egg-info/SOURCES.txt
 check_systemd.egg-info/dependency_links.txt
+check_systemd.egg-info/entry_points.txt
 check_systemd.egg-info/requires.txt
-check_systemd.egg-info/top_level.txt
-test/test_mock.py
-test/test_subprocess.py
+check_systemd.egg-info/top_level.txt

check_systemd-2.0.3/check_systemd.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+check_systemd = check_systemd:main
+

check_systemd-2.0.3/check_systemd.py

@@ -0,0 +1,347 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+You can redistribute it and/or modify it under the terms of the GNU General
+Public License as published by the Free Software Foundation, either version 2
+of the License.
+Copyright 2014-18 Andrea Briganti a.k.a 'Kbyte'
+Copyright 2019 Josef Friedrich
+"""
+import io
+import subprocess
+import argparse
+import re
+
+import nagiosplugin
+from nagiosplugin import Metric
+
+__version__ = '2.0.3'
+
+
+class SystemdctlListUnitsResource(nagiosplugin.Resource):
+    """
+    :param list excludes: A list of systemd unit names.
+    """
+    name = 'SYSTEMD'
+
+    def __init__(self, excludes=[]):
+        self.excludes = excludes
+
+    def probe(self):
+        """Query system state and return metrics.
+
+        :return: generator that emits
+          :class:`~nagiosplugin.metric.Metric` objects
+        """
+        # We don’t use `systemctl --failed --no-legend`, because we want to
+        # collect performance data of all units.
+        try:
+            p = subprocess.Popen(['systemctl', 'list-units', '--all',
+                                  '--no-legend'],
+                                 stderr=subprocess.PIPE,
+                                 stdin=subprocess.PIPE,
+                                 stdout=subprocess.PIPE)
+            stdout, stderr = p.communicate()
+        except OSError as e:
+            raise nagiosplugin.CheckError(e)
+
+        if stderr:
+            raise nagiosplugin.CheckError(stderr)
+
+        # Dictionary to store all units according their active state.
+        units = {
+            'failed': [],
+            'active': [],
+            'activating': [],
+            'inactive': [],
+        }
+        if stdout:
+            # Output of `systemctl list-units --all --no-legend`:
+            # UNIT           LOAD   ACTIVE SUB     JOB   DESCRIPTION
+            # foobar.service loaded active waiting       Description text
+            count_units = 0
+            for line in io.StringIO(stdout.decode('utf-8')):
+                split_line = line.split()
+                # foobar.service
+                unit = split_line[0]
+                # failed
+                active = split_line[2]
+                # Only count not excludes units.
+                if unit not in self.excludes:
+                    units[active].append(unit)
+                    count_units += 1
+
+            for unit in units['failed']:
+                if unit not in self.excludes:
+                    yield Metric(name=unit, value='failed', context='unit')
+
+            for active, unit_names in units.items():
+                yield Metric(name='units_{}'.format(active),
+                             value=len(units[active]),
+                             context='performance_data')
+
+            yield Metric(name='count_units', value=count_units,
+                         context='performance_data')
+
+        if len(units['failed']) == 0:
+            yield Metric(name='all', value=None, context='unit')
+
+
+def format_timespan_to_seconds(fmt_timespan):
+    """Convert a timespan format string into secondes.
+
+    :param str fmt_timespan: for example `2.345s` or `3min 45.234s`
+
+    :return: The seconds
+    :rtype: float
+    """
+    seconds = {
+        'y': 365 * 24 * 60 * 60,
+        'month': 30 * 24 * 60 * 60,
+        'w': 7 * 24 * 60 * 60,
+        'd': 24 * 60 * 60,
+        'h': 60 * 60,
+        'min': 60,
+        's': 1,
+    }
+    result = 0
+    for span in fmt_timespan.split():
+        match = re.search(r'([\d\.]+)([a-z]+)', span)
+        value = match.group(1)
+        unit = match.group(2)
+        result += float(value) * seconds[unit]
+    return round(float(result), 3)
+
+
+class SystemdAnalyseResource(nagiosplugin.Resource):
+
+    name = 'SYSTEMD'
+
+    def probe(self):
+        """Query system state and return metrics.
+
+        :return: generator that emits
+          :class:`~nagiosplugin.metric.Metric` objects
+        """
+        try:
+            p = subprocess.Popen(['systemd-analyze'],
+                                 stderr=subprocess.PIPE,
+                                 stdin=subprocess.PIPE,
+                                 stdout=subprocess.PIPE)
+            stdout, stderr = p.communicate()
+        except OSError as e:
+            raise nagiosplugin.CheckError(e)
+
+        if stderr:
+            raise nagiosplugin.CheckError(stderr)
+
+        if stdout:
+            # Second line:
+            # graphical.target reached after 1min 2.154s in userspace
+            match = re.search(r'reached after (.+) in userspace',
+                              stdout.decode('utf-8'))
+
+        yield Metric(name='startup_time',
+                     value=format_timespan_to_seconds(match.group(1)),
+                     context='startup_time')
+
+
+class SystemctlIsActiveResource(nagiosplugin.Resource):
+
+    name = 'SYSTEMD'
+
+    def __init__(self, *args, **kwargs):
+        self.unit = kwargs.pop('unit')
+        super(nagiosplugin.Resource, self).__init__(*args, **kwargs)
+
+    def probe(self):
+        """Query system state and return metrics.
+
+        :return: generator that emits
+          :class:`~nagiosplugin.metric.Metric` objects
+        """
+        # Execute `systemctl is-active <service>` and get output
+        # - active
+        # - inactive (by unkown unit file)
+        # - failed
+        try:
+            p = subprocess.Popen(['systemctl', 'is-active', self.unit],
+                                 stderr=subprocess.PIPE,
+                                 stdin=subprocess.PIPE,
+                                 stdout=subprocess.PIPE)
+            stdout, stderr = p.communicate()
+        except OSError as e:
+            raise nagiosplugin.CheckError(e)
+
+        if stderr:
+            raise nagiosplugin.CheckError(stderr)
+        if stdout:
+            for line in io.StringIO(stdout.decode('utf-8')):
+                active = line.strip()
+                yield Metric(name=self.unit, value=active, context='unit')
+
+
+class UnitContext(nagiosplugin.Context):
+
+    def __init__(self):
+        super(UnitContext, self).__init__('unit')
+
+    def evaluate(self, metric, resource):
+        """Determines state of a given metric.
+
+        :param metric: associated metric that is to be evaluated
+        :param resource: resource that produced the associated metric
+            (may optionally be consulted)
+        :returns: :class:`~.result.Result`
+        """
+        hint = '%s: %s' % (metric.name, metric.value) \
+            if metric.value else metric.name
+        if metric.value and metric.value != 'active':
+            return self.result_cls(nagiosplugin.Critical, metric=metric,
+                                   hint=hint)
+        else:
+            return self.result_cls(nagiosplugin.Ok, metric=metric, hint=hint)
+
+
+class PerformanceDataContext(nagiosplugin.Context):
+
+    def __init__(self):
+        super(PerformanceDataContext, self).__init__('performance_data')
+
+    def performance(self, metric, resource):
+        """Derives performance data from a given metric.
+
+        :param metric: associated metric from which performance data are
+            derived
+        :param resource: resource that produced the associated metric
+            (may optionally be consulted)
+
+        :returns: :class:`Perfdata` object
+        """
+        return nagiosplugin.Performance(label=metric.name, value=metric.value)
+
+
+class SystemdSummary(nagiosplugin.Summary):
+
+    def ok(self, results):
+        """Formats status line when overall state is ok.
+
+        :param results: :class:`~nagiosplugin.result.Results` container
+        :returns: status line
+        """
+        for result in results.most_significant:
+            if isinstance(result.context, UnitContext):
+                return '{0}'.format(result)
+        return 'all'
+
+    def problem(self, results):
+        """Formats status line when overall state is not ok.
+
+        :param results: :class:`~.result.Results` container
+        :returns: status line
+        """
+        summary = []
+        for result in results.most_significant:
+            if result.context.name in ['startup_time', 'unit']:
+                summary.append(result)
+        return ', '.join(['{0}'.format(result) for result in summary])
+
+    def verbose(self, results):
+        """Provides extra lines if verbose plugin execution is requested.
+
+        :param results: :class:`~.result.Results` container
+        :returns: list of strings
+        """
+        summary = []
+        for result in results.most_significant:
+            if result.context.name in ['startup_time', 'unit']:
+                summary.append('{0}: {1}'.format(result.state, result))
+        return summary
+
+
+def get_argparser():
+    parser = argparse.ArgumentParser(
+        description='Nagios / Icinga monitoring plugin to check systemd for '
+                    'failed units.'
+    )
+
+    exclusive_group = parser.add_mutually_exclusive_group()
+
+    parser.add_argument(
+        '-c', '--critical',
+        metavar='SECONDS',
+        default=120,
+        help='Startup time in seconds to result in critical status.',
+    )
+
+    exclusive_group.add_argument(
+        '-e', '--exclude',
+        metavar='UNIT',
+        action='append',
+        default=[],
+        help='Exclude a systemd unit from the checks. This option can be '
+             'applied multiple times. For example: -e mnt-data.mount -e '
+             'task.service.',
+    )
+
+    exclusive_group.add_argument(
+        '-u', '--unit',
+        type=str,
+        dest='unit',
+        help='Name of the systemd unit that is beeing tested.',
+    )
+
+    parser.add_argument(
+        '-v', '--verbose',
+        action='count',
+        default=0,
+        help='Increase output verbosity (use up to 3 times).'
+    )
+
+    parser.add_argument(
+        '-V', '--version',
+        action='version',
+        version='%(prog)s {}'.format(__version__),
+    )
+
+    parser.add_argument(
+        '-w', '--warning',
+        default=60,
+        metavar='SECONDS',
+        help='Startup time in seconds to result in warning status.',
+    )
+
+    return parser
+
+
+@nagiosplugin.guarded
+def main():
+    args = get_argparser().parse_args()
+
+    objects = []
+
+    if args.unit:
+        objects.append(SystemctlIsActiveResource(unit=args.unit))
+    else:
+        objects += [
+            SystemdctlListUnitsResource(excludes=args.exclude),
+            PerformanceDataContext(),
+            SystemdAnalyseResource(),
+        ]
+
+    objects += [
+        UnitContext(),
+        nagiosplugin.ScalarContext(
+            name='startup_time',
+            warning=args.warning,
+            critical=args.critical,
+        ),
+        SystemdSummary()
+    ]
+
+    check = nagiosplugin.Check(*objects)
+    check.main(args.verbose)
+
+
+if __name__ == '__main__':
+    main()

{check_systemd-2.0.1 → check_systemd-2.0.3}/setup.py

@@ -4,8 +4,9 @@ from setuptools import setup, find_packages
 
 HERE = os.path.abspath(os.path.dirname(__file__))
 
+
 def read(*parts):
-    with open(os.path.join(HERE, *parts), 'r') as fp:
+    with open(os.path.join(HERE, *parts), 'r', encoding='utf-8') as fp:
         return fp.read()
 
 
@@ -21,6 +22,7 @@ def find_version(*file_paths):
 
     raise RuntimeError("Unable to find version string.")
 
+
 setup(
     name='check_systemd',
     packages=find_packages(),
@@ -29,25 +31,31 @@ setup(
     install_requires=[
         'nagiosplugin>=1.2',
     ],
-    description='A simple nagios plugin that detects failed systemd units.',
+    description='Nagios / Icinga monitoring plugin to check systemd for '
+                'failed units.',
     long_description=read('README.md'),
     long_description_content_type='text/markdown',
-    author='Andrea Briganti',
-    author_email='kbytesys@gmail.com',
+    author='Josef Friedrich',
+    author_email='josef@friedrich.rocks',
     url='https://github.com/Josef-Friedrich/check_systemd',
     keywords=['nagios', 'systemd'],
     license='GNU LGPL v2',
+    python_requires='>=3.6',
     classifiers=[
         'Development Status :: 5 - Production/Stable',
         'Environment :: Plugins',
         'Intended Audience :: System Administrators',
-        'License :: OSI Approved :: GNU Lesser General Public License v2 (LGPLv2)',
+        'License :: OSI Approved :: GNU Lesser General Public License v2 '
+        '(LGPLv2)',
         'Programming Language :: Python',
-        'Programming Language :: Python :: 2',
         'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.6',
         'Operating System :: POSIX :: Linux',
         'Topic :: System :: Networking :: Monitoring'
     ],
+    entry_points={
+        'console_scripts': [
+            'check_systemd = check_systemd:main',
+        ],
+    },
 )
-
-

check_systemd-2.0.1/MANIFEST.in

@@ -1 +0,0 @@
-include LICENSE

check_systemd-2.0.1/PKG-INFO

@@ -1,32 +0,0 @@
-Metadata-Version: 2.1
-Name: check_systemd
-Version: 2.0.1
-Summary: A simple nagios plugin that detects failed systemd units.
-Home-page: https://github.com/Josef-Friedrich/check_systemd
-Author: Andrea Briganti
-Author-email: kbytesys@gmail.com
-License: GNU LGPL v2
-Description: [![Build Status](https://travis-ci.org/Josef-Friedrich/check_systemd.svg?branch=master)](https://travis-ci.org/Josef-Friedrich/check_systemd)
-        
-        # check_systemd
-        
-        Simple and easy nagios check for systemd status.
-        
-        This Python script will report a degraded system to nagios and requires only the nagiosplugin library.
-        
-        You can also test a single service with -s parameter.
-        
-        Released under GNU GPLv2 License.
-        
-Keywords: nagios,systemd
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Plugins
-Classifier: Intended Audience :: System Administrators
-Classifier: License :: OSI Approved :: GNU Lesser General Public License v2 (LGPLv2)
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Topic :: System :: Networking :: Monitoring
-Description-Content-Type: text/markdown

check_systemd-2.0.1/README.md

@@ -1,11 +0,0 @@
-[![Build Status](https://travis-ci.org/Josef-Friedrich/check_systemd.svg?branch=master)](https://travis-ci.org/Josef-Friedrich/check_systemd)
-
-# check_systemd
-
-Simple and easy nagios check for systemd status.
-
-This Python script will report a degraded system to nagios and requires only the nagiosplugin library.
-
-You can also test a single service with -s parameter.
-
-Released under GNU GPLv2 License.

check_systemd-2.0.1/check_systemd.egg-info/PKG-INFO

@@ -1,32 +0,0 @@
-Metadata-Version: 2.1
-Name: check-systemd
-Version: 2.0.1
-Summary: A simple nagios plugin that detects failed systemd units.
-Home-page: https://github.com/Josef-Friedrich/check_systemd
-Author: Andrea Briganti
-Author-email: kbytesys@gmail.com
-License: GNU LGPL v2
-Description: [![Build Status](https://travis-ci.org/Josef-Friedrich/check_systemd.svg?branch=master)](https://travis-ci.org/Josef-Friedrich/check_systemd)
-        
-        # check_systemd
-        
-        Simple and easy nagios check for systemd status.
-        
-        This Python script will report a degraded system to nagios and requires only the nagiosplugin library.
-        
-        You can also test a single service with -s parameter.
-        
-        Released under GNU GPLv2 License.
-        
-Keywords: nagios,systemd
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Plugins
-Classifier: Intended Audience :: System Administrators
-Classifier: License :: OSI Approved :: GNU Lesser General Public License v2 (LGPLv2)
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Topic :: System :: Networking :: Monitoring
-Description-Content-Type: text/markdown

check_systemd-2.0.1/check_systemd.py

@@ -1,146 +0,0 @@
-#!/usr/bin/env python
-"""
-You can redistribute it and/or modify it under the terms of the GNU General
-Public License as published by the Free Software Foundation, either version 2
-of the License.
-Copyright Andrea Briganti a.k.a 'Kbyte'
-"""
-import io
-import subprocess
-import argparse
-
-import nagiosplugin
-
-__version__ = '2.0.1'
-
-
-class SystemdStatus(nagiosplugin.Resource):
-    """
-    :param list excludes: A list of systemd unit names.
-    """
-    name = 'SYSTEMD'
-
-    def __init__(self, excludes=[]):
-        self.excludes = excludes
-
-    def probe(self):
-        # Execute systemctl --failed --no-legend and get output
-        try:
-            p = subprocess.Popen(['systemctl', '--failed', '--no-legend'],
-                                 stderr=subprocess.PIPE,
-                                 stdin=subprocess.PIPE,
-                                 stdout=subprocess.PIPE)
-            stdout, stderr = p.communicate()
-        except OSError as e:
-            raise nagiosplugin.CheckError(e)
-
-        if stderr:
-            raise nagiosplugin.CheckError(stderr)
-
-        if stdout:
-            for line in io.StringIO(stdout.decode('utf-8')):
-                split_line = line.split()
-                unit = split_line[0]
-                active = split_line[2]
-                if unit not in self.excludes:
-                    yield nagiosplugin.Metric(unit, active, context='systemd')
-
-        yield nagiosplugin.Metric('all', None, context='systemd')
-
-
-class ServiceStatus(nagiosplugin.Resource):
-    name = 'SYSTEMD'
-
-    def __init__(self, *args, **kwargs):
-        self.service = kwargs.pop('service')
-        super(nagiosplugin.Resource, self).__init__(*args, **kwargs)
-
-    def probe(self):
-        # Execute systemctl is-active and get output
-        try:
-            p = subprocess.Popen(['systemctl', 'is-active', self.service],
-                                 stderr=subprocess.PIPE,
-                                 stdin=subprocess.PIPE,
-                                 stdout=subprocess.PIPE)
-            stdout, stderr = p.communicate()
-        except OSError as e:
-            raise nagiosplugin.CheckError(e)
-
-        if stderr:
-            raise nagiosplugin.CheckError(stderr)
-        if stdout:
-            for line in io.StringIO(stdout.decode('utf-8')):
-                yield nagiosplugin.Metric(self.service, line.strip(),
-                                          context='systemd')
-
-
-class SystemdContext(nagiosplugin.Context):
-
-    def __init__(self):
-        super(SystemdContext, self).__init__('systemd')
-
-    def evaluate(self, metric, resource):
-        hint = '%s: %s' % (metric.name, metric.value) \
-            if metric.value else metric.name
-        if metric.value and metric.value != 'active':
-            return self.result_cls(nagiosplugin.Critical, metric=metric,
-                                   hint=hint)
-        else:
-            return self.result_cls(nagiosplugin.Ok, metric=metric, hint=hint)
-
-
-class SystemdSummary(nagiosplugin.Summary):
-
-    def problem(self, results):
-        return ', '.join(['{0}'.format(result)
-                         for result in results.most_significant])
-
-    def verbose(self, results):
-        return ['{0}: {1}'.format(result.state, result) for result in results]
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    exclusive_group = parser.add_mutually_exclusive_group()
-
-    exclusive_group.add_argument(
-        '-e', '--exclude',
-        metavar='UNIT',
-        action='append',
-        default=[],
-        help='Exclude a systemd unit from the checks. This option can be '
-             'applied multiple times. For example: -e mnt-data.mount -e '
-             'task.service'
-    )
-
-    exclusive_group.add_argument(
-        '-s', '--service',
-        type=str,
-        dest='service',
-        help='Name of the Service that is beeing tested'
-    )
-
-    parser.add_argument(
-        '-v', '--verbose',
-        action='count',
-        default=0,
-        help='Increase output verbosity (use up to 3 times)'
-    )
-
-    args = parser.parse_args()
-
-    if args.service is None:
-        check = nagiosplugin.Check(
-            SystemdStatus(excludes=args.exclude),
-            SystemdContext(),
-            SystemdSummary())
-    else:
-        check = nagiosplugin.Check(
-            ServiceStatus(service=args.service),
-            SystemdContext(),
-            SystemdSummary())
-    check.main(args.verbose)
-
-
-if __name__ == '__main__':
-    main()

check_systemd-2.0.1/test/test_mock.py

@@ -1,25 +0,0 @@
-import unittest
-from unittest import mock
-import check_systemd
-
-
-def mock_main(argv=['check_systemd.py'], stdout=None, stderr=None):
-    with mock.patch('sys.exit') as sys_exit, \
-            mock.patch('check_systemd.subprocess.Popen') as Popen, \
-            mock.patch('sys.argv', argv):
-        process = Popen.return_value
-        process.communicate.return_value = (stdout, stderr)
-        check_systemd.main()
-
-    return {'sys_exit': sys_exit}
-
-
-class TestMock(unittest.TestCase):
-
-    def test_ok(self):
-        result = mock_main()
-        result['sys_exit'].assert_called_with(0)
-
-
-if __name__ == '__main__':
-    unittest.main()

check_systemd-2.0.1/test/test_subprocess.py

@@ -1,142 +0,0 @@
-import unittest
-import os
-import subprocess
-
-
-class AddBin(object):
-    """
-    :param string bin_path: Path relative to the test folder.
-    """
-
-    def __init__(self, bin_path):
-        self.bin_path = bin_path
-        self.old_path = os.environ['PATH']
-
-    def __enter__(self):
-        BIN = os.path.abspath(os.path.join(os.path.dirname(__file__),
-                              self.bin_path))
-        os.environ['PATH'] = BIN + ':' + os.environ['PATH']
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        os.environ['PATH'] = self.old_path
-
-
-class TestSubprocess(unittest.TestCase):
-
-    def test_ok(self):
-        with AddBin('bin/ok'):
-            process = subprocess.run(
-                ['./check_systemd.py'],
-                encoding='utf-8',
-                stdout=subprocess.PIPE,
-            )
-        self.assertEqual(process.returncode, 0)
-        self.assertEqual(process.stdout, 'SYSTEMD OK - all\n')
-
-    def test_ok_verbose(self):
-        with AddBin('bin/ok'):
-            process = subprocess.run(
-                ['./check_systemd.py', '--verbose'],
-                encoding='utf-8',
-                stdout=subprocess.PIPE,
-            )
-        self.assertEqual(process.returncode, 0)
-        self.assertEqual(process.stdout, 'SYSTEMD OK - all\nok: all\n')
-
-    def test_failure(self):
-        with AddBin('bin/failure'):
-            process = subprocess.run(
-                ['./check_systemd.py'],
-                encoding='utf-8',
-                stdout=subprocess.PIPE,
-            )
-        self.assertEqual(process.returncode, 2)
-        self.assertEqual(process.stdout,
-                         'SYSTEMD CRITICAL - test.service: failed\n')
-
-    def test_failure_verbose(self):
-        with AddBin('bin/failure'):
-            process = subprocess.run(
-                ['./check_systemd.py', '-v'],
-                encoding='utf-8',
-                stdout=subprocess.PIPE,
-            )
-        self.assertEqual(process.returncode, 2)
-        self.assertEqual(
-            process.stdout,
-            'SYSTEMD CRITICAL - test.service: failed\n'
-            'critical: test.service: failed\n'
-            'ok: all\n'
-        )
-
-    def test_failure_multiple(self):
-        with AddBin('bin/multiple_failure'):
-            process = subprocess.run(
-                ['./check_systemd.py'],
-                encoding='utf-8',
-                stdout=subprocess.PIPE,
-            )
-        self.assertEqual(process.returncode, 2)
-        self.assertEqual(
-            process.stdout,
-            'SYSTEMD CRITICAL - test1.service: failed, '
-            'test2.service: failed\n'
-        )
-
-    def test_failure_multiple_verbose(self):
-        with AddBin('bin/multiple_failure'):
-            process = subprocess.run(
-                ['./check_systemd.py', '--verbose'],
-                encoding='utf-8',
-                stdout=subprocess.PIPE,
-            )
-        self.assertEqual(process.returncode, 2)
-        self.assertEqual(
-            process.stdout,
-            'SYSTEMD CRITICAL - test1.service: failed, '
-            'test2.service: failed\n'
-            'critical: test1.service: failed\n'
-            'critical: test2.service: failed\n'
-            'ok: all\n'
-        )
-
-    def test_exclusive_group(self):
-        process = subprocess.run(
-            ['./check_systemd.py', '-s', 'test1.service', '-e',
-             'test2.service'],
-            encoding='utf-8',
-            stderr=subprocess.PIPE
-        )
-        self.assertEqual(process.returncode, 2)
-        self.assertIn(
-            'error: argument -e/--exclude: not allowed with argument '
-            '-s/--service',
-            process.stderr,
-        )
-
-    def test_option_exclude_known_service(self):
-        with AddBin('bin/failure'):
-            process = subprocess.run(
-                ['./check_systemd.py', '-e', 'test.service'],
-                encoding='utf-8',
-                stdout=subprocess.PIPE
-            )
-        self.assertEqual(process.returncode, 0)
-        self.assertEqual(process.stdout, 'SYSTEMD OK - all\n')
-
-    def test_option_exclude_unknown_service(self):
-        with AddBin('bin/failure'):
-            process = subprocess.run(
-                ['./check_systemd.py', '-e', 'testX.service'],
-                encoding='utf-8',
-                stdout=subprocess.PIPE
-            )
-        self.assertEqual(process.returncode, 2)
-        self.assertEqual(
-            process.stdout,
-            'SYSTEMD CRITICAL - test.service: failed\n'
-        )
-
-
-if __name__ == '__main__':
-    unittest.main()