Beispiel #1
0
int32_t test_operate_timer()
{
    int32_t i = 0;

    evsets_t sets = NULL;
    event_t * events = NULL;

    sets = evsets_create();
    events = malloc( sizeof(event_t) * NTEST );

    for ( i = 0; i < NTEST; ++i )
    {
        events[i] = event_create();
        event_set_callback( events[i], ev_callback, NULL );
    }

    test_addtimer( sets, events );
    test_deltimer( sets, events );

    for ( i = 0; i < NTEST; ++i )
    {
        event_destroy( events[i] );
    }
    free( events );

    evsets_destroy( sets );

    return 0;
}
int main( int argc, char ** argv )
{
    uint8_t i = 0;
    uint16_t port = 0;
    uint8_t threadcount = 0;

    struct acceptor * a = NULL;
    struct iothread ** thrgroup = NULL;

    if ( argc != 3 )
    {
        printf("echoserver [port] [threadcount] .\n");
        return 0;
    }

    signal( SIGPIPE, SIG_IGN );
    signal( SIGINT, echoserver_signal_handler );
    signal( SIGTERM, echoserver_signal_handler );

    port = (uint16_t)atoi( argv[1] );
    threadcount = (uint8_t)atoi( argv[2] );

    a = acceptor_create( "127.0.0.1", port );

    thrgroup = (struct iothread **)malloc( threadcount*sizeof(struct iothread *) );
    for ( i = 0; i < threadcount; ++i )
    {
        thrgroup[i] = iothread_create( i+1, a );
    }

    isstarted = 1;
    while ( isstarted )
    {
    #if defined(__FreeBSD__)
        sleep(2);
    #else
        pause();
    #endif
    }

    for ( i = 0; i < threadcount; ++i )
    {
        evsets_destroy( thrgroup[i]->core_sets );
    }

    return 0;
}
Beispiel #3
0
int32_t test_evtimer()
{
    evsets_t sets = NULL;
    event_t ev_timer = NULL;

    sets = evsets_create();

    ev_timer = event_create();
    event_set( ev_timer, -1, 0 );
    event_set_callback( ev_timer, ev_timer_callback, ev_timer );

    evsets_add( sets, ev_timer, 2*1000 );

    while( 1 )
    {
        evsets_dispatch( sets );
    }

    event_destroy( ev_timer );
    evsets_destroy( sets );

    return 0;
}
Beispiel #4
0
int32_t iothread_stop( struct iothread * self )
{
    if ( self->queue )
    {
        msgqueue_destroy( self->queue );
        self->queue = NULL;
    }

    if ( self->cmdevent )
    {
        evsets_del( self->sets, self->cmdevent );
        event_destroy( self->cmdevent );
        self->cmdevent = NULL;
    }

    if ( self->sets )
    {
        evsets_destroy( self->sets );
        self->sets = NULL;
    }

    return 0;
}
int main( int argc, char ** argv )
{
    if ( argc != 2 )
    {
        printf("echoserver [port] .\n");
        return 0;
    }

    evsets_t coreset = evsets_create();
    if ( coreset == NULL )
    {
        printf( "create core event sets failed .\n" );
        goto FINAL;
    }

    signal( SIGPIPE, SIG_IGN );
    signal( SIGINT, echoserver_signal_handler );
    signal( SIGTERM, echoserver_signal_handler );

    // listen port
    uint16_t port = (uint16_t)atoi( argv[1] );
    int32_t fd = tcp_listen( "127.0.0.1", port, listenfd_options );
    if ( fd < 0 )
    {
        printf( "listen failed %d .\n", port );
        goto FINAL;
    }
    set_non_block( fd );
    event_t evaccept = event_create();
    if ( evaccept == NULL )
    {
        printf( "create accept event failed .\n" );
        goto FINAL;
    }
    event_set( evaccept, fd, EV_READ|EV_PERSIST );
    event_set_callback( evaccept, accept_new_session, coreset );
    evsets_add( coreset, evaccept, 0 );

    // running ...
    isrunning = 1;
    while ( isrunning == 1 )
    {
        evsets_dispatch( coreset );
    }

FINAL :
    if ( evaccept != NULL )
    {
        event_destroy( evaccept );
    }

    if ( fd > 0 )
    {
        close( fd );
    }

    if ( coreset != NULL )
    {
        evsets_destroy( coreset );
    }

    return 0;
}