Пример #1
0
    def test_loading_variables_after_services(self):
        '''
        Test parsing of a Yaml flow with variables referenced before
        their definition in another file.
        '''
        self.cfg.load_from_stream('''
services:
     S1:
            desc: "I'm the service S1"
            target: "%TARGET_VAR"
            actions:
                start:
                    cmd: echo %LUSTRE_FS_LIST
---
variables:
    TARGET_VAR: foo
    LUSTRE_FS_LIST: store0,work0''')

        self.cfg.build_graph()

        srv = service_manager_self().entities['S1']
        self.assertTrue('LUSTRE_FS_LIST' in service_manager_self().variables)
        self.assertTrue('TARGET_VAR' in service_manager_self().variables)
        self.assertEqual(str(srv.target), "foo")
        self.assertEqual(srv._actions['start'].command, "echo %LUSTRE_FS_LIST")
        self.assertTrue(len(self.cfg._flow) == 2)
Пример #2
0
    def test_execute_unknown_exception(self):
        """CLI return '12' if an unknown exception is raised."""
        service_manager_self().call_services = None
        self._output_check(['S2', 'start'], RC_UNKNOWN_EXCEPTION, "",
"""[00:00:00] ERROR    - Unexpected Exception : 'NoneType'"""\
""" object is not callable
""")
Пример #3
0
    def test_parse_with_services_syntax(self):
        '''Test loading with empty YAML document in flow.'''
        self.cfg.load_from_stream('''---
services:
    foo[1-2]:
        desc: "this is desc"
        require: [ 'bar' ]
        actions:
            start:
                cmd: run %NAME
    bar:
        actions:
            start:
                cmd: run_bar''')

        self.cfg.build_graph()
        # Get back the manager
        manager = service_manager_self()
        self.assertTrue('foo1' in manager.entities)
        self.assertTrue('foo2' in manager.entities)
        self.assertTrue('bar' in manager.entities)
        self.assertTrue(manager.entities['foo1'].has_action('start'))
        self.assertTrue(manager.entities['foo1'].has_parent_dep('bar'))
        self.assertTrue(manager.entities['foo2'].has_action('start'))
        self.assertTrue(manager.entities['foo2'].has_parent_dep('bar'))
        self.assertTrue(manager.entities['bar'].has_action('start'))
Пример #4
0
    def test_parse_with_services_syntax(self):
        '''Test loading with empty YAML document in flow.'''
        self.cfg.load_from_stream('''---
services:
    foo[1-2]:
        desc: "this is desc"
        require: [ 'bar' ]
        actions:
            start:
                cmd: run %NAME
    bar:
        actions:
            start:
                cmd: run_bar''')

        self.cfg.build_graph()
        # Get back the manager
        manager = service_manager_self()
        self.assertTrue('foo1' in manager.entities)
        self.assertTrue('foo2' in manager.entities)
        self.assertTrue('bar' in manager.entities)
        self.assertTrue(manager.entities['foo1'].has_action('start'))
        self.assertTrue(manager.entities['foo1'].has_parent_dep('bar'))
        self.assertTrue(manager.entities['foo2'].has_action('start'))
        self.assertTrue(manager.entities['foo2'].has_parent_dep('bar'))
        self.assertTrue(manager.entities['bar'].has_action('start'))
Пример #5
0
    def test_ScannerError_output(self):
        '''Test command line output on ScannerError'''
        service_manager_self().call_services = \
                lambda services, action, conf=None: raiser(ScannerError)
        self._output_check(['start'], RC_EXCEPTION,
'''''',
'''[00:00:00] ERROR    - 
''')
Пример #6
0
    def test_KeyboardInterrupt_output(self):
        '''Test command line output on KeybordInterrupt'''
        service_manager_self().call_services = \
                lambda services, action, conf=None : raiser(KeyboardInterrupt)
        self._output_check(['start'], (128 + SIGINT),
'''''',
'''[00:00:00] ERROR    - Keyboard Interrupt
''')
Пример #7
0
    def test_UnhandledException_output(self):
        '''Test command line output on UnhandledException'''
        service_manager_self().call_services = \
                lambda services, action, conf=None: raiser(ZeroDivisionError)
        self._output_check(['start'], RC_UNKNOWN_EXCEPTION,
'''''',
'''[00:00:00] ERROR    - Unexpected Exception : 
''')
Пример #8
0
 def test_empty_only_nodes(self):
     '''Test_apply_config with empty nodeset in only_nodes'''
     empty_ns = NodeSet()
     manager = service_manager_self()
     s1 = Service('S1', target = NodeSet("localhost"))
     manager.register_services(s1)
     conf = {'only_nodes': empty_ns}
     manager._apply_config(conf)
     self.assertEqual(s1.target, empty_ns)
Пример #9
0
    def test_remove_variable(self):
        '''Remove a variable, defined or not, is fine.'''
        manager = service_manager_self()
        manager.add_var('var', 'foo')
        self.assertEqual(manager.variables['var'], 'foo')

        # Remove it
        manager.remove_var('var')
        self.assertTrue('foo' not in manager.variables)
Пример #10
0
    def test_ActionNotFound_output(self):
        '''Test command line output on ActionNotFound'''
        service_manager_self().call_services = \
                lambda services, action, conf=None: raiser(
                                        ActionNotFoundError("Test", "Debug"))
        self._output_check(['start'], RC_EXCEPTION,
'''''',
'''[00:00:00] ERROR    - Action [Debug] not referenced for [Test]
''')
Пример #11
0
    def retcode(self):
        '''
        Determine a retcode from a the last point of the graph
            RC_OK = 0: Everything went as we expected
            RC_WARNING = 3: At least one service status is WARNING
                            and all others status is OK
            RC_ERROR = 6: At least one service status is ERROR

        Handled by self.execute :
            RC_EXCEPTION = 9: User error (options or configuration)
            RC_UNKNOWN_EXCEPTION = 12: Internal error (this is probably a bug)
        '''
        if service_manager_self().source.status in (DEP_ERROR, ERROR):
            return RC_ERROR
        elif service_manager_self().has_warnings():
            return RC_WARNING
        else:
            return RC_OK
Пример #12
0
 def test_empty_excluded_nodes(self):
     '''Test _apply_config with empty nodeset in excluded_nodes'''
     localhost_ns = NodeSet("localhost")
     manager = service_manager_self()
     s1 = Service('S1', target = localhost_ns)
     manager.register_services(s1)
     conf = {'excluded_nodes': NodeSet()}
     manager._apply_config(conf)
     self.assertEqual(s1.target, localhost_ns)
Пример #13
0
    def setUp(self):
        ConfigParser.DEFAULT_FIELDS['config_dir']['value'] = ''
        ConfigParser.CONFIG_PATH = '/dev/null'

        ServiceManager._instance = None 
        self.manager = service_manager_self()
        ActionManager._instance = None

        # Setup stdout and stderr as a MyOutput file
        sys.stdout = MyOutput()
        sys.stderr = MyOutput()
Пример #14
0
    def _lookup_variable(self, varname):
        '''
        Return the value of the specified variable name.

        If is not found in current object, it searches recursively in the
        parent object.
        If it cannot solve the variable name, it raises UndefinedVariableError.
        '''
        from MilkCheck.ServiceManager import service_manager_self

        if varname in self.variables:
            return self.variables[varname]
        elif varname.upper() in self.LOCAL_VARIABLES:
            value = self.LOCAL_VARIABLES[varname.upper()]
            return self.resolve_property(value)
        elif self.parent:
            return self.parent._lookup_variable(varname)
        elif varname in service_manager_self().variables:
            return service_manager_self().variables[varname]
        else:
            raise UndefinedVariableError(varname)
Пример #15
0
 def test_call_services_reversed(self):
     '''Test service_manager with custom reversed actions'''
     manager = service_manager_self()
     s1 = Service('S1')
     s2 = Service('S2')
     s1.add_action(Action('wait', command='/bin/true'))
     s2.add_action(Action('wait', command='/bin/true'))
     s1.add_dep(s2)
     manager.register_services(s1, s2)
     manager.call_services(['S1'], 'wait',
                     conf={"reverse_actions": ['wait']})
     self.assertTrue(s1._algo_reversed)
     self.assertTrue(s2._algo_reversed)
Пример #16
0
 def test_service_registration(self):
     '''Test the resgistration of a service within the manager'''
     manager = service_manager_self()
     srvtest = Service('test')
     manager.register_service(srvtest)
     self.assertTrue(manager.has_service(srvtest))
     self.assertRaises(ServiceAlreadyReferencedError,
         manager.register_service, Service('test'))
     srva = Service('A')
     srvb = Service('B')
     manager.register_services(srva, srvb)
     self.assertTrue(manager.has_service(srva))
     self.assertTrue(manager.has_service(srvb))
Пример #17
0
    def test_graph(self):
        '''Test DOT graph output'''
        manager = service_manager_self()
        sergrp = ServiceGroup('S1')
        sergrp.fromdict(
           {'services':
                {'srv1':
                     {'target': 'localhost',
                      'actions':
                        {'start': {'cmd':'/bin/True'},
                         'stop': {'cmd': '/bin/False'}},
                      'desc': "I'm the service srv1"
                    },
                'subgroup':
                    {'services':
                        {'svcB':
                            {'require_weak':['svcC'],
                            'actions':
                                {'start': {'cmd': '/bin/True'},
                            '   stop': {'cmd': '/bin/False'}},
                            'desc': 'I am the subservice $NAME'},
                        'svcC':
                            {'actions':
                                {'start': {'cmd': '/bin/True'},
                                'stop': {'cmd': '/bin/False'}},
                                'desc': 'I am the subservice $NAME'}},
                        'target': '127.0.0.1',
                        'desc': "I'm the service $NAME"}},
                })
        manager.register_services(sergrp)
        self.assertEqual(manager.output_graph(), 
"""digraph dependency {
compound=true;
node [style=filled];
subgraph "cluster_S1" {
label="S1";
style=rounded;
node [style=filled];
"S1.__hook" [style=invis];
"S1.srv1";
subgraph "cluster_S1.subgroup" {
label="S1.subgroup";
style=rounded;
node [style=filled];
"S1.subgroup.__hook" [style=invis];
"S1.subgroup.svcB" -> "S1.subgroup.svcC" [style=dashed];
"S1.subgroup.svcC";
}
}
}
""")
Пример #18
0
 def test_building_graph(self):
     '''Test graph building from configuration'''
     dty = '../tests/MilkCheckTests/ConfigTests/YamlTestFiles/sample_1/'
     self.cfg.load_from_dir(dty)
     self.cfg._build_services()
     # Get back the manager
     manager = service_manager_self()
     self.assertTrue('S1' in manager.entities)
     self.assertTrue('S2' in manager.entities)
     self.assertTrue('S3' in manager.entities)
     self.assertTrue('S4' in manager.entities)
     self.assertTrue(manager.entities['S1'].has_parent_dep('S2'))
     self.assertTrue(manager.entities['S1'].has_parent_dep('S3'))
     self.assertTrue(manager.entities['S3'].has_parent_dep('S4'))
     self.assertTrue(manager.entities['S2'].has_parent_dep('S4'))
     self.assertTrue(manager.entities['S4'].has_parent_dep('G1'))
Пример #19
0
 def test_building_graph(self):
     '''Test graph building from configuration'''
     dty = '../tests/MilkCheckTests/ConfigTests/YamlTestFiles/sample_1/'
     self.cfg.load_from_dir(dty)
     self.cfg._build_services()
     # Get back the manager
     manager = service_manager_self()
     self.assertTrue('S1' in manager.entities)
     self.assertTrue('S2' in manager.entities)
     self.assertTrue('S3' in manager.entities)
     self.assertTrue('S4' in manager.entities)
     self.assertTrue(manager.entities['S1'].has_parent_dep('S2'))
     self.assertTrue(manager.entities['S1'].has_parent_dep('S3'))
     self.assertTrue(manager.entities['S3'].has_parent_dep('S4'))
     self.assertTrue(manager.entities['S2'].has_parent_dep('S4'))
     self.assertTrue(manager.entities['S4'].has_parent_dep('G1'))
Пример #20
0
 def test_call_services_reversed_multiple(self):
     '''Test service_manager with multiple custom reversed actions'''
     manager = service_manager_self()
     s1 = Service('S1')
     s2 = Service('S2')
     s1.add_action(Action('stop', command='/bin/true'))
     s2.add_action(Action('wait', command='/bin/true'))
     manager.register_services(s1, s2)
     actions = ['stop', 'wait']
     for act in actions:
         s1._algo_reversed = False
         s2._algo_reversed = False
         manager.call_services(['S1'], act,
                         conf={"reverse_actions": actions})
         self.assertTrue(s1._algo_reversed)
         self.assertTrue(s2._algo_reversed)
Пример #21
0
 def test_call_services_retcode6(self):
     '''Test call_services return 6 whether source is DEP_ERROR'''
     manager = service_manager_self()
     s1 = Service('S1')
     s2 = Service('S2')
     s3 = Service('S3')
     s4 = Service('S4')
     s1.add_action(Action('start', command='/bin/true'))
     s2.add_action(Action('start', command='/bin/false'))
     s3.add_action(Action('start', command='/bin/true'))
     s4.add_action(Action('start', command='/bin/true'))
     s1.add_dep(target=s2)
     s2.add_dep(target=s3)
     s2.add_dep(target=s4)
     manager.register_services(s1, s2, s3, s4)
     manager.call_services([], 'start')
     self.assertTrue(manager.source.status in (ERROR, DEP_ERROR))
Пример #22
0
    def test_call_services_parallelism(self):
        '''Test services parallelism'''
        manager = service_manager_self()
        s1 = Service('S1')
        s2 = Service('S2')
        s1.add_action(Action('wait', command='/bin/sleep 0.5'))
        s2.add_action(Action('wait', command='/bin/sleep 0.5'))
        manager.register_services(s1, s2)

        elapsed = time.time()
        manager.call_services(['S1', 'S2'], 'wait')
        elapsed = time.time() - elapsed
        self.assertTrue(elapsed < 0.7, 'Time elapsed too high (%f)' % elapsed)
        self.assertTrue(manager.source.status not in (ERROR, DEP_ERROR,
                                                            WARNING))
        self.assertEqual(s1.status, DONE)
        self.assertEqual(s2.status, DONE)
Пример #23
0
 def test_call_services_retcode_weak(self):
     '''Test call_services return 0 (OK) even with require_weak'''
     manager = service_manager_self()
     s1 = Service('S1')
     s2 = Service('S2')
     s3 = Service('S3')
     s4 = Service('S4')
     s1.add_action(Action('start', command='/bin/true'))
     s2.add_action(Action('start', command='/bin/false'))
     s3.add_action(Action('start', command='/bin/true'))
     s4.add_action(Action('start', command='/bin/true'))
     s1.add_dep(target=s2, sgth=REQUIRE_WEAK)
     s2.add_dep(target=s3)
     s2.add_dep(target=s4)
     manager.register_services(s1, s2, s3, s4)
     manager.call_services([], 'start')
     self.assertEqual(manager.source.status, DONE)
Пример #24
0
    def test_set_variables_before_configuration_parsing(self):
        '''
        Test parsing of Yaml flow with variables prevously defined
        '''
        manager = service_manager_self()
        manager.add_var('MY_VAR', 'bar')
        self.cfg.load_from_stream('''
variables:
    MY_VAR: foo
---
services:
     S1:
            desc: "I'm the service S1"
            actions:
                start:
                    cmd: echo %MY_VAR''')
        self.cfg.build_graph()
        self.assertTrue(manager.variables['MY_VAR'] == 'bar')
Пример #25
0
    def test_after_rule_parsing(self):
        """'after' is supported in configuration"""
        self.cfg.load_from_stream('''
services:
    foo:
        actions:
            start:
                cmd: run %NAME
    bar:
        after: [ 'foo' ]
        actions:
            start:
                cmd: run_bar''')
        self.cfg.build_graph()
        manager = service_manager_self()
        self.assertTrue('foo' in manager.entities)
        self.assertTrue('bar' in manager.entities)
        self.assertTrue(manager.entities['bar'].has_parent_dep('foo'))
Пример #26
0
    def test_after_rule_parsing(self):
        """'after' is supported in configuration"""
        self.cfg.load_from_stream('''
services:
    foo:
        actions:
            start:
                cmd: run %NAME
    bar:
        after: [ 'foo' ]
        actions:
            start:
                cmd: run_bar''')
        self.cfg.build_graph()
        manager = service_manager_self()
        self.assertTrue('foo' in manager.entities)
        self.assertTrue('bar' in manager.entities)
        self.assertTrue(manager.entities['bar'].has_parent_dep('foo'))
Пример #27
0
 def test_forget_service(self):
     '''The how the manager forgets a service properly'''
     manager = service_manager_self()
     s1 = Service('S1')
     s2 = Service('S2')
     s3 = Service('S3')
     s4 = Service('S4')
     s1.add_dep(target=s2)
     s2.add_dep(target=s3)
     s2.add_dep(target=s4)
     manager.register_services(s1, s2, s3, s4)
     manager.forget_service(s1)
     self.assertFalse(manager.has_service(s1))
     self.assertFalse(s1.has_parent_dep('S2'))
     self.assertFalse(s2.has_child_dep('S1'))
     manager.forget_services(s2, s4)
     self.assertFalse(manager.has_service(s2))
     self.assertFalse(manager.has_service(s4))
     self.assertFalse(s4.has_child_dep('S3'))
     self.assertFalse(s3.has_parent_dep('S4'))
Пример #28
0
 def test_call_services_case_errors(self):
     '''Test errors generated by call_services'''
     manager = service_manager_self()
     s1 = Service('S1')
     s2 = Service('S2')
     s3 = Service('S3')
     s4 = Service('S4')
     s1.add_action(Action('start', command='%TARGET'))
     s2.add_action(Action('start', command='/bin/true'))
     s3.add_action(Action('start', command='/bin/true'))
     s4.add_action(Action('start', command='/bin/true'))
     s1.add_dep(target=s2)
     s2.add_dep(target=s3)
     s2.add_dep(target=s4)
     manager.register_services(s1, s2, s3, s4)
     self.assertRaises(AssertionError,
         manager.call_services, None, None)
     self.assertRaises(ServiceNotFoundError,
         manager.call_services, ['S8'], 'start')
     self.assertRaises(ServiceNotFoundError,
         manager.call_services, ['S2', 'S8'], 'start')
Пример #29
0
    def test_graph_service_exlcude(self):
        """Test the DOT graph output with excluded nodes"""
        ''' Graph:
            E3 -> E2 -> E1 -> D0
                          `-> D1
        '''
        manager = service_manager_self()
        entd0 = Service('D0')
        entd1 = Service('D1')
        ente1 = Service('E1')
        ente2 = Service('E2')
        ente3 = Service('E3')
        ente3.add_dep(ente2)
        ente2.add_dep(ente1)
        ente1.add_dep(entd0)
        ente1.add_dep(entd1)
        manager.register_services(entd0, entd1, ente1, ente2, ente3)
        self.assertEqual(manager.output_graph(excluded=['E2']),
"""digraph dependency {
compound=true;
node [style=filled];
"E1" -> "D0";
"E1" -> "D1";
"D0";
"D1";
}
""")
        self.assertEqual(manager.output_graph(excluded=['D0']),
"""digraph dependency {
compound=true;
node [style=filled];
"D1";
}
""")
        self.assertEqual(manager.output_graph(excluded=['D0', 'D1']),
"""digraph dependency {
compound=true;
node [style=filled];
}
""")
Пример #30
0
    def test_deps_between_top_services(self):
        '''Deps between 2 services in top "services" section are ok'''
        self.cfg.load_from_stream('''
services:
    foo:
        actions:
            start:
                cmd: run %NAME
---
services:
    bar:
        require: [ 'foo' ]
        actions:
            start:
                cmd: run_bar''')
        self.cfg.build_graph()
        manager = service_manager_self()
        self.assertTrue('foo' in manager.entities)
        self.assertTrue('bar' in manager.entities)
        self.assertTrue(manager.entities['foo'].has_action('start'))
        self.assertTrue(manager.entities['bar'].has_action('start'))
        self.assertTrue(manager.entities['bar'].has_parent_dep('foo'))
Пример #31
0
 def test_call_services_case2(self):
     '''Test call of required services (start S3, S4)'''
     manager = service_manager_self()
     s1 = Service('S1')
     s2 = Service('S2')
     s3 = Service('S3')
     s4 = Service('S4')
     s1.add_action(Action('start', command='/bin/true'))
     s2.add_action(Action('start', command='/bin/true'))
     s3.add_action(Action('start', command='/bin/true'))
     s4.add_action(Action('start', command='/bin/true'))
     s1.add_dep(target=s2)
     s2.add_dep(target=s3)
     s2.add_dep(target=s4)
     manager.register_services(s1, s2, s3, s4)
     manager.call_services(['S3','S4'], 'start')
     self.assertTrue(manager.source.status not in (ERROR, DEP_ERROR,
                                                         WARNING))
     self.assertEqual(s1.status, NO_STATUS)
     self.assertEqual(s2.status, NO_STATUS)
     self.assertEqual(s3.status, DONE)
     self.assertEqual(s4.status, DONE)
Пример #32
0
    def test_deps_between_top_services(self):
        '''Deps between 2 services in top "services" section are ok'''
        self.cfg.load_from_stream('''
services:
    foo:
        actions:
            start:
                cmd: run %NAME
---
services:
    bar:
        require: [ 'foo' ]
        actions:
            start:
                cmd: run_bar''')
        self.cfg.build_graph()
        manager = service_manager_self()
        self.assertTrue('foo' in manager.entities)
        self.assertTrue('bar' in manager.entities)
        self.assertTrue(manager.entities['foo'].has_action('start'))
        self.assertTrue(manager.entities['bar'].has_action('start'))
        self.assertTrue(manager.entities['bar'].has_parent_dep('foo'))
Пример #33
0
    def test_InvalidOptionError_output(self):
        '''Test command line output on InvalidOption'''
        service_manager_self().call_services = \
                lambda services, action, conf=None: raiser(InvalidOptionError)
        self._output_check(['start'], RC_EXCEPTION,
'''Usage: nosetests [options] [SERVICE...] ACTION

Options:
  --version             show program's version number and exit
  -h, --help            show this help message and exit
  -v, --verbose         Increase or decrease verbosity
  -d, --debug           Set debug mode and maximum verbosity
  -g, --graph           Output dependencies graph
  -s, --summary         Display summary of executed actions
  -c CONFIG_DIR, --config-dir=CONFIG_DIR
                        Change configuration files directory
  -q, --quiet           Enable quiet mode

  Engine parameters:
    Those options allow you to configure the behaviour of the engine

    -n ONLY_NODES, --only-nodes=ONLY_NODES
                        Use only the specified nodes
    -x EXCLUDED_NODES, --exclude-nodes=EXCLUDED_NODES
                        Exclude the cluster's nodes specified
    -X EXCLUDED_SVC, --exclude-service=EXCLUDED_SVC
                        Skip the specified services
    --dry-run           Only simulate command execution
    -D DEFINES, --define=DEFINES, --var=DEFINES
                        Define custom variables
    --nodeps            Do not run dependencies
''',
'''[00:00:00] CRITICAL - Invalid options: 

[00:00:00] CRITICAL - Invalid options: 

''')
Пример #34
0
    def test_UnhandledExceptionDebug_output(self):
        '''Test command line output on UnhandledException in debug mode'''
        service_manager_self().call_services = \
                lambda services, action, conf=None: raiser(ZeroDivisionError)
        self._output_check(['start', '-d'], RC_UNKNOWN_EXCEPTION,
'''Traceback (most recent call last):
  File "source.py", line 000, in execute
    manager.call_services(services, action, conf=self._conf)
  File "source.py", line 000, in <lambda>
    lambda services, action, conf=None: raiser(ZeroDivisionError)
  File "source.py", line 000, in raiser
    raise exception
ZeroDivisionError
''',
'''[00:00:00] DEBUG    - Configuration
nodeps: False
dryrun: False
verbosity: 5
summary: False
fanout: 64
reverse_actions: ['stop']
debug: True
config_dir: 
''')
Пример #35
0
 def tearDown(self):
     service_manager_self().reset()
Пример #36
0
 def tearDown(self):
     '''Restore ServiceManager'''
     CLICommon.tearDown(self)
     service_manager_self().call_services = self.call_services_backup
Пример #37
0
 def setUp(self):
     '''
     Set up mocking to test exceptions
     '''
     CLICommon.setUp(self)
     self.call_services_backup = service_manager_self().call_services