Ejemplo n.º 1
0
def test_run_event_handler():
    """
    This stuff really needs better tests.
    """
    from node_tools import state_data as st
    from node_tools.data_funcs import get_state_values

    home, pid_file, log_file, debug, msg, mode, role = do_setup()

    nets = ['b6079f73c63cea29', 'b6079f73ca8129ad']
    net_q.clear()
    # for nwid in nets:
    #     net_q.append(nwid)

    net_id_handler('fpn_id0', 'b6079f73c63cea29')
    net_id_handler('fpn_id1', 'b6079f73ca8129ad')

    for nwid in nets:
        net_id_handler(None, nwid, old=True)

    prev_state = AttrDict.from_nested_dict(st.defState)
    next_state = AttrDict.from_nested_dict(st.defState)
    assert not st.changes

    get_state_values(prev_state, next_state)
    run_event_handlers(st.changes)
    assert len(st.changes) == 0

    next_state.update(fpn0=True,
                      fpn1=True,
                      fpn_id0='b6079f73c63cea29',
                      fpn_id1='b6079f73ca8129ad')
    get_state_values(prev_state, next_state)
    run_event_handlers(st.changes)
    log_fpn_state(st.changes)
    assert len(st.changes) == 4

    network_cruft_cleaner()
Ejemplo n.º 2
0
def do_scheduling():
    set_initial_role()
    network_cruft_cleaner()
    schedule.run_all(1, 'base-tasks')
    validate_role()
    node_role = NODE_SETTINGS['node_role']
    mode = NODE_SETTINGS['mode']
    if node_role is None and mode == 'peer':
        NODE_SETTINGS['use_localhost'] = True

    if mode == 'peer':
        if node_role is None:
            check_time = 33
            baseCheckJob = schedule.every(check_time).seconds
            baseCheckJob.do(run_net_check).tag('base-tasks', 'route-status')

            try:
                data = wait_for_moon(timeout=45)
            except Exception as exc:
                logger.error('ENODATA exception {}'.format(exc))
                put_state_msg('ERROR')

            try:
                handle_moon_data(data)
                put_state_msg('STARTING')
            except MemberNodeError as exc:
                logger.error('ENODATA exception {}'.format(exc))
                put_state_msg('ERROR')

            str_level = logging.getLevelName(logger.getEffectiveLevel())
            logger.debug('Current log level is: {}'.format(str_level))
            startup_handlers()

        else:
            if node_role == 'controller':
                netobj_q = dc.Deque(directory=get_cachedir('netobj_queue'))
                gen_netobj_queue(netobj_q)
                cache = dc.Index(get_cachedir())
                for key_str in ['peer', 'moon', 'mstate']:
                    delete_cache_entry(cache, key_str)

            elif node_role == 'moon':
                cln_q = dc.Deque(directory=get_cachedir('clean_queue'))
                pub_q = dc.Deque(directory=get_cachedir('pub_queue'))
                schedule.every(37).seconds.do(run_cleanup_check, cln_q,
                                              pub_q).tag(
                                                  'chk-tasks', 'cleanup')
                schedule.every(15).minutes.do(check_daemon_status).tag(
                    'chk-tasks', 'responder')

            schedule.every(15).minutes.do(check_daemon_status,
                                          script='msg_subscriber.py').tag(
                                              'chk-tasks', 'subscriber')
            schedule.run_all(1, 'chk-tasks')

    elif mode == 'adhoc':
        logger.debug('Running in adhoc mode...')
        if NODE_SETTINGS['nwid']:
            logger.debug('ADHOC: found network {}'.format(
                NODE_SETTINGS['nwid']))
            do_startup(NODE_SETTINGS['nwid'])
        else:
            logger.error('No network ID found in NODE_SETTINGS!!')
            logger.error('Have you created a network yet?')

    logger.debug('MODE: startup mode is {} and role is {}'.format(
        mode, node_role))
    logger.info(
        'You are running fpnd/node_tools version {}'.format(fpnd_version))

    while True:
        schedule.run_pending()
        time.sleep(1)