Merge lp:~ubuntuone-pqm-team/charmsupport/trunk into lp:charmsupport

[Sidnei da Silva]

Support both the nrpe-external-monitor and plain nrpe charms. Notify local-monitors relation if established (noop if the relation is not there). Added tests for the nrpe module.

[Matthew Wedgwood (mew)]

This looks good overall.

One problem I found, this fails when JUJU_UNIT_NAME is set in the environment:

NRPETestCase
  test_init_gets_config
    self.assertEqual('testunit', checker.unit_name)

review: Needs Fixing

[lp:~ubuntuone-pqm-team/charmsupport/trunk]

42. By Sidnei da Silva on 2013-03-18

- Patch os.environ properly so environment doesn't affect tests.

[Sidnei da Silva (sidnei)]

Fixed. After merging, we should start looking at getting this built into a PPA.

[lp:~ubuntuone-pqm-team/charmsupport/trunk]

43. By Sidnei da Silva on 2013-04-02

- Add relation_get helper command.

44. By Sidnei da Silva on 2013-04-02

- Make relation_ids return all ids if relation type is not present nor informed.

45. By Sidnei da Silva on 2013-04-02

- Make related_units work without a relation too.

46. By Sidnei da Silva on 2013-04-02

- Fix relations_for_id to pass rid on.

47. By Sidnei da Silva on 2013-04-02

- Proxy dict attributes directly.

48. By Sidnei da Silva on 2013-04-02

- Use UserDict as base class for Serializable, make it more dict-like.

49. By Sidnei da Silva on 2013-04-03

- Missing argument needs a '-'

50. By David Ames on 2013-04-24

[r=sidnei] Fix dictionary check for volume_map
Allow non-relation context runs

51. By Sidnei da Silva on 2013-05-10

[r=sidnei] Fix relations_for_id to use relation_id not relation_ids.

Unmerged revisions

51. By Sidnei da Silva on 2013-05-10

[r=sidnei] Fix relations_for_id to use relation_id not relation_ids.

=== modified file 'Makefile'
--- Makefile	2013-02-08 20:18:15 +0000
+++ Makefile	2013-04-02 22:26:22 +0000
@@ -31,9 +31,11 @@
 	python setup.py install --user
 
 test:
-	nosetests tests/
+	@echo Starting tests...
+	@nosetests tests/
 
 lint:
-	flake8 $(PROJECT) $(TESTS)
+	@echo Checking for Python syntax...
+	@flake8 --ignore=E123 $(PROJECT) $(TESTS) && echo OK
 
 build: test lint

=== modified file 'charmsupport/hookenv.py'
--- charmsupport/hookenv.py	2013-03-07 15:28:36 +0000
+++ charmsupport/hookenv.py	2013-04-02 22:26:22 +0000
@@ -8,13 +8,14 @@
 import json
 import yaml
 import subprocess
-
+import UserDict
 
 CRITICAL = "CRITICAL"
 ERROR = "ERROR"
 WARNING = "WARNING"
 INFO = "INFO"
 DEBUG = "DEBUG"
+MARKER = object()
 
 
 def log(message, level=None):
@@ -26,30 +27,35 @@
     subprocess.call(command)
 
 
-class Serializable(object):
+class Serializable(UserDict.IterableUserDict):
     "Wrapper, an object that can be serialized to yaml or json"
+
     def __init__(self, obj):
         # wrap the object
-        super(Serializable, self).__init__()
-        self._wrapped_obj = obj
+        UserDict.IterableUserDict.__init__(self)
+        self.data = obj
 
     def __getattr__(self, attr):
-        # see if this object has attr
-        if attr in self.__dict__:
-            return getattr(self, attr)
-        # proxy to the wrapped object
-        return self[attr]
-
-    def __getitem__(self, key):
-        return self._wrapped_obj[key]
+        # See if this object has attribute.
+        if attr in ("json", "yaml", "data"):
+            return self.__dict__[attr]
+        # Check for attribute in wrapped object.
+        got = getattr(self.data, attr, MARKER)
+        if got is not MARKER:
+            return got
+        # Proxy to the wrapped object via dict interface.
+        try:
+            return self.data[attr]
+        except KeyError:
+            raise AttributeError(attr)
 
     def json(self):
         "Serialize the object to json"
-        return json.dumps(self._wrapped_obj)
+        return json.dumps(self.data)
 
     def yaml(self):
         "Serialize the object to yaml"
-        return yaml.dump(self._wrapped_obj)
+        return yaml.dump(self.data)
 
 
 def execution_environment():
@@ -69,12 +75,12 @@
 
 def relation_type():
     "The scope for the current relation hook"
-    return os.environ['JUJU_RELATION']
+    return os.environ.get('JUJU_RELATION', None)
 
 
 def relation_id():
     "The relation ID for the current relation hook"
-    return os.environ['JUJU_RELATION_ID']
+    return os.environ.get('JUJU_RELATION_ID', None)
 
 
 def local_unit():
@@ -101,32 +107,49 @@
     return Serializable(config_data)
 
 
+def relation_get(attribute=None, unit=None, rid=None):
+    _args = ['relation-get', '--format=json']
+    if rid:
+        _args.append('-r')
+        _args.append(rid)
+    if attribute is not None:
+        _args.append(attribute)
+    if unit:
+        _args.append(unit)
+    return json.loads(subprocess.check_output(_args))
+
+
+def relation_set(relation_id=None, **kwargs):
+    relation_cmd_line = ['relation-set']
+    if relation_id is not None:
+        relation_cmd_line.extend(('-r', relation_id))
+    for k, v in kwargs.items():
+        relation_cmd_line.append('{}={}'.format(k, v))
+    subprocess.check_call(relation_cmd_line)
+
+
 def relation_ids(reltype=None):
     "A list of relation_ids"
     reltype = reltype or relation_type()
-    relids = []
-    relid_cmd_line = ['relation-ids', '--format=json', reltype]
-    relids.extend(json.loads(subprocess.check_output(relid_cmd_line)))
-    return relids
+    relid_cmd_line = ['relation-ids', '--format=json']
+    if reltype is not None:
+        relid_cmd_line.append(reltype)
+    return json.loads(subprocess.check_output(relid_cmd_line))
 
 
 def related_units(relid=None):
     "A list of related units"
     relid = relid or relation_id()
-    units_cmd_line = ['relation-list', '--format=json', '-r', relid]
-    units = json.loads(subprocess.check_output(units_cmd_line))
-    return units
-
-
-def relation_for_unit(unit=None):
+    units_cmd_line = ['relation-list', '--format=json']
+    if relid is not None:
+        units_cmd_line.extend(('-r', relid))
+    return json.loads(subprocess.check_output(units_cmd_line))
+
+
+def relation_for_unit(unit=None, rid=None):
     "Get the json represenation of a unit's relation"
     unit = unit or remote_unit()
-    relation_cmd_line = ['relation-get', '--format=json', '-', unit]
-    try:
-        relation = json.loads(subprocess.check_output(relation_cmd_line))
-    except (ValueError, OSError, subprocess.CalledProcessError), err:
-        log(str(err), level=ERROR)
-        raise
+    relation = relation_get(unit=unit, rid=rid)
     for key in relation:
         if key.endswith('-list'):
             relation[key] = relation[key].split()
@@ -139,7 +162,7 @@
     relation_data = []
     relid = relid or relation_ids()
     for unit in related_units(relid):
-        unit_data = relation_for_unit(unit)
+        unit_data = relation_for_unit(unit, relid)
         unit_data['__relid__'] = relid
         relation_data.append(unit_data)
     return relation_data
@@ -148,12 +171,11 @@
 def relations_of_type(reltype=None):
     "Get relations of a specific type"
     relation_data = []
-    if in_relation_hook():
-        reltype = reltype or relation_type()
-        for relid in relation_ids(reltype):
-            for relation in relations_for_id(relid):
-                relation['__relid__'] = relid
-                relation_data.append(relation)
+    reltype = reltype or relation_type()
+    for relid in relation_ids(reltype):
+        for relation in relations_for_id(relid):
+            relation['__relid__'] = relid
+            relation_data.append(relation)
     return relation_data
 
 

=== modified file 'charmsupport/nrpe.py'
--- charmsupport/nrpe.py	2013-03-07 14:59:36 +0000
+++ charmsupport/nrpe.py	2013-04-02 22:26:22 +0000
@@ -10,11 +10,13 @@
 import os
 import re
 import shlex
-
-from hookenv import config, local_unit, log
-
-# This module adds compatibility with the nrpe_external_master
-# subordinate charm. To use it in your charm:
+import yaml
+
+from hookenv import config, local_unit, log, relation_ids, relation_set
+from host import service
+
+# This module adds compatibility with the nrpe-external-master and plain nrpe
+# subordinate charms. To use it in your charm:
 #
 # 1. Update metadata.yaml
 #
@@ -24,13 +26,22 @@
 #       interface: nrpe-external-master
 #       scope: container
 #
+#   and/or
+#
+#   provides:
+#     (...)
+#     local-monitors:
+#       interface: local-monitors
+#       scope: container
+
+#
 # 2. Add the following to config.yaml
 #
 #    nagios_context:
 #      default: "juju"
 #      type: string
 #      description: |
-#        Used by the nrpe-external-master subordinate charm.
+#        Used by the nrpe subordinate charms.
 #        A string that will be prepended to instance name to set the host name
 #        in nagios. So for instance the hostname would be something like:
 #            juju-myservice-0
@@ -60,10 +71,15 @@
 #    def config_changed():
 #        (...)
 #        update_nrpe_config()
+#
 #    def nrpe_external_master_relation_changed():
 #        update_nrpe_config()
 #
+#    def local_monitors_relation_changed():
+#        update_nrpe_config()
+#
 # 5. ln -s hooks.py nrpe-external-master-relation-changed
+#    ln -s hooks.py local-monitors-relation-changed
 
 
 class CheckException(Exception):
@@ -71,7 +87,7 @@
 
 
 class Check(object):
-    shortname_re = '[A-Za-z0-9-_]*'
+    shortname_re = '[A-Za-z0-9-_]+$'
     service_template = ("""
 #---------------------------------------------------
 # This file is Juju managed
@@ -80,8 +96,8 @@
     use                             active-service
     host_name                       {nagios_hostname}
     service_description             {nagios_hostname}[{shortname}] """
-                        """"{description}
-    check_command                   check_nrpe!check_{shortname}
+                        """{description}
+    check_command                   check_nrpe!{command}
     servicegroups                   {nagios_servicegroup}
 }}
 """)
@@ -93,6 +109,7 @@
             raise CheckException("shortname must match {}".format(
                 Check.shortname_re))
         self.shortname = shortname
+        self.command = "check_{}".format(shortname)
         # Note: a set of invalid characters is defined by the
         # Nagios server config
         # The default is: illegal_object_name_chars=`~!$%^&*"|'<>?,()=
@@ -106,17 +123,33 @@
                          'files/nrpe-external-master'),
             '/usr/lib/nagios/plugins',
         )
-        command = shlex.split(check_cmd)
+        parts = shlex.split(check_cmd)
         for path in search_path:
-            if os.path.exists(os.path.join(path, command[0])):
-                return os.path.join(path, command[0]) + " " + " ".join(
-                    command[1:])
-        log('Check command not found: {}'.format(command[0]))
+            if os.path.exists(os.path.join(path, parts[0])):
+                command = os.path.join(path, parts[0])
+                if len(parts) > 1:
+                    command += " " + " ".join(parts[1:])
+                return command
+        log('Check command not found: {}'.format(parts[0]))
         return ''
 
     def write(self, nagios_context, hostname):
+        nrpe_check_file = '/etc/nagios/nrpe.d/{}.cfg'.format(
+            self.command)
+        with open(nrpe_check_file, 'w') as nrpe_check_config:
+            nrpe_check_config.write("# check {}\n".format(self.shortname))
+            nrpe_check_config.write("command[{}]={}\n".format(
+                self.command, self.check_cmd))
+
+        if not os.path.exists(NRPE.nagios_exportdir):
+            log('Not writing service config as {} is not accessible'.format(
+                NRPE.nagios_exportdir))
+        else:
+            self.write_service_config(nagios_context, hostname)
+
+    def write_service_config(self, nagios_context, hostname):
         for f in os.listdir(NRPE.nagios_exportdir):
-            if re.search('.*check_{}.cfg'.format(self.shortname), f):
+            if re.search('.*{}.cfg'.format(self.command), f):
                 os.remove(os.path.join(NRPE.nagios_exportdir, f))
 
         templ_vars = {
@@ -124,20 +157,14 @@
             'nagios_servicegroup': nagios_context,
             'description': self.description,
             'shortname': self.shortname,
-        }
+            'command': self.command,
+            }
         nrpe_service_text = Check.service_template.format(**templ_vars)
-        nrpe_service_file = '{}/service__{}_check_{}.cfg'.format(
-            NRPE.nagios_exportdir, hostname, self.shortname)
+        nrpe_service_file = '{}/service__{}_{}.cfg'.format(
+            NRPE.nagios_exportdir, hostname, self.command)
         with open(nrpe_service_file, 'w') as nrpe_service_config:
             nrpe_service_config.write(str(nrpe_service_text))
 
-        nrpe_check_file = '/etc/nagios/nrpe.d/check_{}.cfg'.format(
-            self.shortname)
-        with open(nrpe_check_file, 'w') as nrpe_check_config:
-            nrpe_check_config.write("# check {}\n".format(self.shortname))
-            nrpe_check_config.write("command[check_{}]={}\n".format(
-                self.shortname, self.check_cmd))
-
     def run(self):
         subprocess.call(self.check_cmd)
 
@@ -166,17 +193,19 @@
             log("Nagios user not set up, nrpe checks not updated")
             return
 
-        if not os.path.exists(NRPE.nagios_exportdir):
-            log('Exiting as {} is not accessible'.format(
-                NRPE.nagios_exportdir))
-            return
-
         if not os.path.exists(NRPE.nagios_logdir):
             os.mkdir(NRPE.nagios_logdir)
             os.chown(NRPE.nagios_logdir, nagios_uid, nagios_gid)
 
+        nrpe_monitors = {}
+        monitors = {"monitors": {"remote": {"nrpe": nrpe_monitors}}}
         for nrpecheck in self.checks:
             nrpecheck.write(self.nagios_context, self.hostname)
-
-        if os.path.isfile('/etc/init.d/nagios-nrpe-server'):
-            subprocess.call(['service', 'nagios-nrpe-server', 'reload'])
+            nrpe_monitors[nrpecheck.shortname] = {
+                "command": nrpecheck.command,
+                }
+
+        service('restart', 'nagios-nrpe-server')
+
+        for rid in relation_ids("local-monitors"):
+            relation_set(relation_id=rid, monitors=yaml.dump(monitors))

=== modified file 'setup.cfg'
--- setup.cfg	2013-02-08 16:54:43 +0000
+++ setup.cfg	2013-04-02 22:26:22 +0000
@@ -1,5 +1,4 @@
 [nosetests]
 with-coverage=1
 cover-erase=1
-cover-xml=1
 cover-package=charmsupport

=== modified file 'tests/test_hookenv.py'
--- tests/test_hookenv.py	2013-03-07 15:28:36 +0000
+++ tests/test_hookenv.py	2013-04-02 22:26:22 +0000
@@ -30,13 +30,38 @@
 
         self.assertEqual(wrapped.bar, 'baz')
 
+    def test_dict_methods_from_inner_object(self):
+        foo = {
+            'bar': 'baz',
+        }
+        wrapped = hookenv.Serializable(foo)
+        for meth in ('keys', 'values', 'items'):
+            self.assertEqual(getattr(wrapped, meth)(), getattr(foo, meth)())
+
+        for meth in ('iterkeys', 'itervalues', 'iteritems'):
+            self.assertEqual(list(getattr(wrapped, meth)()),
+                             list(getattr(foo, meth)()))
+        self.assertEqual(wrapped.get('bar'), foo.get('bar'))
+        self.assertEqual(wrapped.get('baz', 42), foo.get('baz', 42))
+        self.assertIn('bar', wrapped)
+
+    def test_get_gets_from_inner_object(self):
+        foo = {
+            'bar': 'baz',
+        }
+        wrapped = hookenv.Serializable(foo)
+
+        self.assertEqual(wrapped.get('foo'), None)
+        self.assertEqual(wrapped.get('bar'), 'baz')
+        self.assertEqual(wrapped.get('zoo', 'bla'), 'bla')
+
     def test_gets_inner_object(self):
         foo = {
             'bar': 'baz',
         }
         wrapped = hookenv.Serializable(foo)
 
-        self.assertIs(wrapped._wrapped_obj, foo)
+        self.assertIs(wrapped.data, foo)
 
 
 class HelpersTest(TestCase):
@@ -119,6 +144,11 @@
 
         self.assertEqual(hookenv.relation_type(), 'foo')
 
+    @patch('charmsupport.hookenv.os')
+    def test_relation_type_none_if_not_in_environment(self, os_):
+        os_.environ = {}
+        self.assertEqual(hookenv.relation_type(), None)
+
     @patch('subprocess.check_output')
     @patch('charmsupport.hookenv.relation_type')
     def test_gets_relation_ids(self, relation_type, check_output):
@@ -135,6 +165,18 @@
 
     @patch('subprocess.check_output')
     @patch('charmsupport.hookenv.relation_type')
+    def test_relation_ids_no_relation_type(self, relation_type, check_output):
+        ids = [1, 2, 3]
+        check_output.return_value = json.dumps(ids)
+        relation_type.return_value = None
+
+        result = hookenv.relation_ids()
+
+        self.assertEqual(result, ids)
+        check_output.assert_called_with(['relation-ids', '--format=json'])
+
+    @patch('subprocess.check_output')
+    @patch('charmsupport.hookenv.relation_type')
     def test_gets_relation_ids_for_type(self, relation_type, check_output):
         ids = [1, 2, 3]
         check_output.return_value = json.dumps(ids)
@@ -163,6 +205,18 @@
 
     @patch('subprocess.check_output')
     @patch('charmsupport.hookenv.relation_id')
+    def test_related_units_no_relation(self, relation_id, check_output):
+        units = ['foo', 'bar']
+        relation_id.return_value = None
+        check_output.return_value = json.dumps(units)
+
+        result = hookenv.related_units()
+
+        self.assertEqual(result, units)
+        check_output.assert_called_with(['relation-list', '--format=json'])
+
+    @patch('subprocess.check_output')
+    @patch('charmsupport.hookenv.relation_id')
     def test_gets_related_units_for_id(self, relation_id, check_output):
         relid = 123
         units = ['foo', 'bar']
@@ -183,55 +237,40 @@
 
         self.assertEqual(hookenv.remote_unit(), 'foo')
 
-    @patch('subprocess.check_output')
     @patch('charmsupport.hookenv.remote_unit')
-    def test_gets_relation_for_unit(self, remote_unit, check_output):
+    @patch('charmsupport.hookenv.relation_get')
+    def test_gets_relation_for_unit(self, relation_get, remote_unit):
         unit = 'foo-unit'
         raw_relation = {
             'foo': 'bar',
             'baz-list': '1 2 3',
         }
         remote_unit.return_value = unit
-        check_output.return_value = json.dumps(raw_relation)
+        relation_get.return_value = raw_relation
 
         result = hookenv.relation_for_unit()
 
         self.assertEqual(result.__unit__, unit)
         self.assertEqual(getattr(result, 'baz-list'), ['1', '2', '3'])
-        check_output.assert_called_with(['relation-get', '--format=json', '-',
-                                         unit])
+        relation_get.assert_called_with(unit=unit, rid=None)
 
-    @patch('subprocess.check_output')
     @patch('charmsupport.hookenv.remote_unit')
-    def test_gets_relation_for_specific_unit(self, remote_unit, check_output):
+    @patch('charmsupport.hookenv.relation_get')
+    def test_gets_relation_for_specific_unit(self, relation_get, remote_unit):
         unit = 'foo-unit'
         raw_relation = {
             'foo': 'bar',
             'baz-list': '1 2 3',
         }
-        check_output.return_value = json.dumps(raw_relation)
+        relation_get.return_value = raw_relation
 
         result = hookenv.relation_for_unit(unit)
 
         self.assertEqual(result.__unit__, unit)
         self.assertEqual(getattr(result, 'baz-list'), ['1', '2', '3'])
-        check_output.assert_called_with(['relation-get', '--format=json', '-',
-                                         unit])
+        relation_get.assert_called_with(unit=unit, rid=None)
         self.assertFalse(remote_unit.called)
 
-    @patch('subprocess.check_output')
-    @patch('charmsupport.hookenv.log')
-    def test_logs_and_reraises_error_for_relation_for_unit(self, log,
-                                                           check_output):
-        unit = 'foo-unit'
-        error = 'some error'
-        check_output.side_effect = ValueError(error)
-
-        self.assertRaisesRegexp(ValueError, error, hookenv.relation_for_unit,
-                                unit)
-
-        log.assert_called_with(error, level=hookenv.ERROR)
-
     @patch('charmsupport.hookenv.relation_ids')
     @patch('charmsupport.hookenv.related_units')
     @patch('charmsupport.hookenv.relation_for_unit')
@@ -255,8 +294,8 @@
         self.assertEqual(result[1]['foo-item2'], 'bar-item2')
         related_units.assert_called_with(relid)
         self.assertEqual(relation_for_unit.mock_calls, [
-            call('foo'),
-            call('bar'),
+            call('foo', relid),
+            call('bar', relid),
         ])
 
     @patch('charmsupport.hookenv.relation_ids')
@@ -281,8 +320,8 @@
         self.assertEqual(result[1]['foo-item2'], 'bar-item2')
         related_units.assert_called_with(relid)
         self.assertEqual(relation_for_unit.mock_calls, [
-            call('foo'),
-            call('bar'),
+            call('foo', relid),
+            call('bar', relid),
         ])
         self.assertFalse(relation_ids.called)
 
@@ -327,24 +366,6 @@
             call(234),
         ])
 
-    @patch('charmsupport.hookenv.in_relation_hook')
-    @patch('charmsupport.hookenv.relation_type')
-    @patch('charmsupport.hookenv.relation_ids')
-    @patch('charmsupport.hookenv.relations_for_id')
-    def test_gets_nothing_for_relations_if_not_in_hook(self, relations_for_id,
-                                                       relation_ids,
-                                                       relation_type,
-                                                       in_relation_hook):
-        is_in_relation = False
-        in_relation_hook.return_value = is_in_relation
-
-        result = hookenv.relations_of_type()
-
-        self.assertEqual(result, [])
-        self.assertFalse(relations_for_id.called)
-        self.assertFalse(relation_ids.called)
-        self.assertFalse(relation_type.called)
-
     @patch('charmsupport.hookenv.config')
     @patch('charmsupport.hookenv.local_unit')
     @patch('charmsupport.hookenv.relations_of_type')
@@ -373,6 +394,55 @@
 
         self.assertEqual(hookenv.relation_id(), 'foo')
 
+    @patch('charmsupport.hookenv.os')
+    def test_relation_id_none_if_no_env(self, os_):
+        os_.environ = {}
+        self.assertEqual(hookenv.relation_id(), None)
+
+    @patch('subprocess.check_output')
+    def test_gets_relation(self, check_output):
+        json_string = '{"foo": "BAR"}'
+        check_output.return_value = json_string
+
+        result = hookenv.relation_get()
+
+        self.assertEqual(result['foo'], 'BAR')
+        check_output.assert_called_with(['relation-get', '--format=json'])
+
+    @patch('subprocess.check_output')
+    def test_gets_relation_with_scope(self, check_output):
+        json_string = '{"foo": "BAR"}'
+        check_output.return_value = json_string
+
+        result = hookenv.relation_get(attribute='baz-scope')
+
+        self.assertEqual(result['foo'], 'BAR')
+        check_output.assert_called_with(['relation-get', '--format=json',
+                                         'baz-scope'])
+
+    @patch('subprocess.check_output')
+    def test_gets_relation_with_unit_name(self, check_output):
+        json_string = '{"foo": "BAR"}'
+        check_output.return_value = json_string
+
+        result = hookenv.relation_get(attribute='baz-scope', unit='baz-unit')
+
+        self.assertEqual(result['foo'], 'BAR')
+        check_output.assert_called_with(['relation-get', '--format=json',
+                                         'baz-scope', 'baz-unit'])
+
+    @patch('subprocess.check_output')
+    def test_gets_relation_with_relation_id(self, check_output):
+        json_string = '{"foo": "BAR"}'
+        check_output.return_value = json_string
+
+        result = hookenv.relation_get(attribute='baz-scope', unit='baz-unit',
+                                      rid=123)
+
+        self.assertEqual(result['foo'], 'BAR')
+        check_output.assert_called_with(['relation-get', '--format=json', '-r',
+                                         123, 'baz-scope', 'baz-unit'])
+
 
 class HooksTest(TestCase):
     def test_runs_a_registered_function(self):

=== added file 'tests/test_nrpe.py'
--- tests/test_nrpe.py	1970-01-01 00:00:00 +0000
+++ tests/test_nrpe.py	2013-04-02 22:26:22 +0000
@@ -0,0 +1,222 @@
+import os
+import yaml
+import subprocess
+
+from testtools import TestCase
+from mock import patch, call
+
+from charmsupport import nrpe
+
+
+class NRPEBaseTestCase(TestCase):
+    patches = {
+        'config': {'object': nrpe},
+        'log': {'object': nrpe},
+        'getpwnam': {'object': nrpe.pwd},
+        'getgrnam': {'object': nrpe.grp},
+        'mkdir': {'object': os},
+        'chown': {'object': os},
+        'exists': {'object': os.path},
+        'listdir': {'object': os},
+        'remove': {'object': os},
+        'open': {'object': nrpe, 'create': True},
+        'isfile': {'object': os.path},
+        'call': {'object': subprocess},
+        'relation_ids': {'object': nrpe},
+        'relation_set': {'object': nrpe},
+    }
+
+    def setUp(self):
+        super(NRPEBaseTestCase, self).setUp()
+        self.patched = {}
+        # Mock the universe.
+        for attr, data in self.patches.items():
+            create = data.get('create', False)
+            patcher = patch.object(data['object'], attr, create=create)
+            self.patched[attr] = patcher.start()
+            self.addCleanup(patcher.stop)
+        env_patcher = patch.dict('os.environ',
+                                 {'JUJU_UNIT_NAME': 'testunit',
+                                  'CHARM_DIR': '/usr/lib/test_charm_dir'})
+        env_patcher.start()
+        self.addCleanup(env_patcher.stop)
+
+    def check_call_counts(self, **kwargs):
+        for attr, expected in kwargs.items():
+            patcher = self.patched[attr]
+            self.assertEqual(expected, patcher.call_count, attr)
+
+
+class NRPETestCase(NRPEBaseTestCase):
+
+    def test_init_gets_config(self):
+        self.patched['config'].return_value = {'nagios_context': 'testctx'}
+
+        checker = nrpe.NRPE()
+
+        self.assertEqual('testctx', checker.nagios_context)
+        self.assertEqual('testunit', checker.unit_name)
+        self.assertEqual('testctx-testunit', checker.hostname)
+        self.check_call_counts(config=1)
+
+    def test_no_nagios_installed_bails(self):
+        self.patched['config'].return_value = {'nagios_context': 'test'}
+        self.patched['getgrnam'].side_effect = KeyError
+        checker = nrpe.NRPE()
+
+        self.assertEqual(None, checker.write())
+
+        expected = 'Nagios user not set up, nrpe checks not updated'
+        self.patched['log'].assert_called_once_with(expected)
+        self.check_call_counts(log=1, config=1, getpwnam=1, getgrnam=1)
+
+    def test_write_no_checker(self):
+        self.patched['config'].return_value = {'nagios_context': 'test'}
+        self.patched['exists'].return_value = True
+        checker = nrpe.NRPE()
+
+        self.assertEqual(None, checker.write())
+
+        self.check_call_counts(config=1, getpwnam=1, getgrnam=1, exists=2)
+
+    def test_write_restarts_service(self):
+        self.patched['config'].return_value = {'nagios_context': 'test'}
+        self.patched['exists'].return_value = True
+        checker = nrpe.NRPE()
+
+        self.assertEqual(None, checker.write())
+
+        expected = ['initctl', 'restart', 'nagios-nrpe-server']
+        self.assertEqual(expected, self.patched['call'].call_args[0][0])
+        self.check_call_counts(config=1, getpwnam=1, getgrnam=1,
+                               exists=2, call=1)
+
+    def test_update_nrpe(self):
+        self.patched['config'].return_value = {'nagios_context': 'a'}
+        self.patched['exists'].return_value = True
+        self.patched['relation_ids'].return_value = ['local-monitors:1']
+
+        checker = nrpe.NRPE()
+        checker.add_check(shortname="myservice",
+                          description="Check MyService",
+                          check_cmd="check_http http://localhost")
+
+        self.assertEqual(None, checker.write())
+
+        self.assertEqual(2, self.patched['open'].call_count)
+        filename = 'check_myservice.cfg'
+        expected = [
+            ('/etc/nagios/nrpe.d/%s' % filename, 'w'),
+            ('/var/lib/nagios/export/service__a-testunit_%s' % filename, 'w'),
+        ]
+        actual = [x[0] for x in self.patched['open'].call_args_list]
+        self.assertEqual(expected, actual)
+        outfile = self.patched['open'].return_value.__enter__.return_value
+        service_file_contents = """
+#---------------------------------------------------
+# This file is Juju managed
+#---------------------------------------------------
+define service {
+    use                             active-service
+    host_name                       a-testunit
+    service_description             a-testunit[myservice] Check MyService
+    check_command                   check_nrpe!check_myservice
+    servicegroups                   a
+}
+"""
+        expected = [
+            '# check myservice\n',
+            'command[check_myservice]=/check_http http://localhost\n',
+            service_file_contents,
+        ]
+        actual = [x[0][0] for x in outfile.write.call_args_list]
+        self.assertEqual(expected, actual)
+
+        nrpe_monitors = {'myservice':
+                         {'command': 'check_myservice'}}
+        monitors = yaml.dump(
+            {"monitors": {"remote": {"nrpe": nrpe_monitors}}})
+        self.patched['relation_set'].assert_called_once_with(
+            relation_id="local-monitors:1", monitors=monitors)
+        self.check_call_counts(config=1, getpwnam=1, getgrnam=1,
+                               exists=4, open=2, listdir=1,
+                               relation_ids=1, relation_set=1)
+
+
+class NRPECheckTestCase(NRPEBaseTestCase):
+
+    def test_invalid_shortname(self):
+        cases = [
+            'invalid:name',
+            '@invalid',
+            '',
+        ]
+        for shortname in cases:
+            self.assertRaises(nrpe.CheckException, nrpe.Check, shortname,
+                              'description', '/some/command')
+
+    def test_valid_shortname(self):
+        cases = [
+            '1_number_is_fine',
+            'dashes-ok',
+            '5',
+        ]
+        for shortname in cases:
+            check = nrpe.Check(shortname, 'description', '/some/command')
+            self.assertEqual(shortname, check.shortname)
+
+    def test_write_removes_existing_config(self):
+        self.patched['listdir'].return_value = [
+            'foo', 'bar.cfg', 'check_shortname.cfg']
+        check = nrpe.Check('shortname', 'description', '/some/command')
+
+        self.assertEqual(None, check.write('testctx', 'hostname'))
+
+        expected = '/var/lib/nagios/export/check_shortname.cfg'
+        self.patched['remove'].assert_called_once_with(expected)
+        self.check_call_counts(exists=2, remove=1, open=2, listdir=1)
+
+    def test_check_write_nrpe_exportdir_not_accessible(self):
+        self.patched['exists'].return_value = False
+        check = nrpe.Check('shortname', 'description', '/some/command')
+
+        self.assertEqual(None, check.write('testctx', 'hostname'))
+        expected = ('Not writing service config as '
+                    '/var/lib/nagios/export is not accessible')
+        self.patched['log'].assert_has_calls(
+            [call(expected)], any_order=True)
+        self.check_call_counts(log=2, open=1)
+
+    def test_locate_cmd_no_args(self):
+        self.patched['exists'].return_value = True
+
+        check = nrpe.Check('shortname', 'description', '/bin/ls')
+
+        self.assertEqual('/bin/ls', check.check_cmd)
+
+    def test_locate_cmd_not_found(self):
+        self.patched['exists'].return_value = False
+        check = nrpe.Check('shortname', 'description', 'check_http -x -y -z')
+
+        self.assertEqual('', check.check_cmd)
+        self.assertEqual(3, self.patched['exists'].call_count)
+        expected = [
+            '/check_http',
+            '/usr/lib/test_charm_dir/files/nrpe-external-master/check_http',
+            '/usr/lib/nagios/plugins/check_http',
+        ]
+        actual = [x[0][0] for x in self.patched['exists'].call_args_list]
+        self.assertEqual(expected, actual)
+        self.check_call_counts(exists=3, log=1)
+        expected = 'Check command not found: check_http'
+        self.assertEqual(expected, self.patched['log'].call_args[0][0])
+
+    def test_run(self):
+        self.patched['exists'].return_value = True
+        command = '/usr/bin/wget foo'
+        check = nrpe.Check('shortname', 'description', command)
+
+        self.assertEqual(None, check.run())
+
+        self.check_call_counts(exists=1, call=1)
+        self.assertEqual(command, self.patched['call'].call_args[0][0])