def register():
    """
    Register our hook state mappings.
    """
    spstates.register('storpool-config', {
        'config-changed': STATES_REDO,
        'upgrade-charm': STATES_REDO,
    })
def install():
    """
    Run a full check-install-update cycle upon first installation.
    """
    rdebug('storpool-repo-add.install invoked')
    spstates.register('storpool-repo-add', {
        'config-changed': STATES_REDO,
        'upgrade-charm': STATES_REDO,
    })
    spstates.handle_single(STATES_REDO)
Exemplo n.º 3
0
    def test_register_unregister(self):
        """
        Test register() and unregister().
        """
        testee.register('a', 'aa')
        self.assertEqual({'a': 'aa'}, testee.get_registered())
        self.assertEqual(set(), r_state.r_get_states())

        testee.register('b', 'bb')
        self.assertEqual({'a': 'aa', 'b': 'bb'}, testee.get_registered())
        self.assertEqual(set(), r_state.r_get_states())

        testee.register('a', -1)
        self.assertEqual({'a': -1, 'b': 'bb'}, testee.get_registered())
        self.assertEqual(set(), r_state.r_get_states())

        testee.unregister('b')
        self.assertEqual({'a': -1}, testee.get_registered())
        self.assertEqual(set(), r_state.r_get_states())

        testee.register('c', set('c'))
        self.assertEqual({'a': -1, 'c': set('c')}, testee.get_registered())
        self.assertEqual(set(), r_state.r_get_states())

        testee.unregister('b')
        self.assertEqual({'a': -1, 'c': set('c')}, testee.get_registered())
        self.assertEqual(set(), r_state.r_get_states())

        testee.unregister('a')
        self.assertEqual({'c': set('c')}, testee.get_registered())
        self.assertEqual(set(), r_state.r_get_states())

        testee.unregister('c')
        self.assertEqual({}, testee.get_registered())
        self.assertEqual(set(), r_state.r_get_states())

        testee.unregister('a')
        testee.unregister('b')
        testee.unregister('c')
        testee.unregister('d')
        self.assertEqual({}, testee.get_registered())
        self.assertEqual(set(), r_state.r_get_states())
Exemplo n.º 4
0
    def test_handle_events(self):
        """
        Test a full lifecycle of events handling.
        """
        states = {
            'f-conf-set':
            set(['first.configure']),
            'f-conf-unset':
            set(['first.configured', 'first.installed']),
            'f-up-set':
            set(['first.configure', 'first.upgrade']),
            'f-up-unset':
            set(['first.configured', 'first.installed']),
            's-conf-set':
            set(['second.configure']),
            's-conf-unset':
            set([
                'second.configured',
                'second.started',
                'second.submitted',
            ]),
            's-start-set':
            set(['second.started']),
            's-start-unset':
            set(['second.submitted']),
        }

        s_all = set()
        for key in states:
            s_all = s_all.union(states[key])
        states['all'] = s_all

        states['pre-conf'] = s_all \
            .difference(states['f-conf-set']) \
            .difference(states['s-conf-set'])
        states['post-conf'] = s_all \
            .difference(states['f-conf-unset']) \
            .difference(states['s-conf-unset'])
        self.assertNotEqual(states['all'], states['pre-conf'])
        self.assertNotEqual(states['all'], states['post-conf'])
        self.assertNotEqual(states['pre-conf'], states['post-conf'])

        states['post-conf-start'] = states['post-conf'] \
            .difference(states['s-start-unset']) \
            .union(states['s-start-set'])
        self.assertNotEqual(states['post-conf-start'], states['post-conf'])
        self.assertNotEqual(states['post-conf-start'], states['all'])

        testee.register(
            'first', {
                'config-changed': {
                    'set': states['f-conf-set'],
                    'unset': states['f-conf-unset'],
                },
                'upgrade-charm': {
                    'set': states['f-up-set'],
                    'unset': states['f-up-unset'],
                },
            })
        self.assertEqual(['first'],
                         sorted(r_kv.get(kvdata.KEY_SET_STATES).keys()))
        self.assertEqual(set(), r_state.r_get_states())

        testee.register(
            'second', {
                'config-changed': {
                    'set': states['s-conf-set'],
                    'unset': states['s-conf-unset'],
                },
                'start': {
                    'set': states['s-start-set'],
                    'unset': states['s-start-unset'],
                },
            })
        self.assertEqual(['first', 'second'],
                         sorted(r_kv.get(kvdata.KEY_SET_STATES).keys()))
        self.assertEqual(set(), r_state.r_get_states())

        # Now let's go
        r_state.r_set_states(states['pre-conf'])

        testee.handle_event('config-changed')
        self.assertEqual(states['post-conf'], r_state.r_get_states())

        testee.handle_event('start')
        self.assertEqual(states['post-conf-start'], r_state.r_get_states())

        r_state.r_clear_states()
        testee.handle_event('config-changed')
        self.assertEqual(states['f-conf-set'].union(states['s-conf-set']),
                         r_state.r_get_states())
def register_states():
    """
    Register for a full reinstall upon an upgrade-charm event.
    """
    spstates.register('storpool-beacon', {'upgrade-charm': STATES_REDO})
Exemplo n.º 6
0
def register():
    """
    Register our hook state mappings.
    """
    spstates.register('storpool-common', {'upgrade-charm': STATES_REDO})