Beispiel #1
0
static int mtcp_read_handler(struct ctx *ctx)
{
    int len, ret;
    char buf[8192];
    struct mtcp_epoll_event evctl;
    
    len = mtcp_read(ctx->worker->mctx, ctx->sockid, buf, sizeof(buf));
    if (len >= 0) {
        ctx->bytes_left -= len;
        if (!ctx->bytes_left) {
            ctx->worker->total_messages++;
            ctx->bytes_left = msg_size;
            if (!ctx->messages_left) {
                close_mtcp_socket(ctx);
                new_connection(ctx);
                return len;
            }
            ctx->messages_left--;
            
            evctl.events = MTCP_EPOLLOUT | MTCP_EPOLLHUP | MTCP_EPOLLRDHUP;
            evctl.data.sockid = ctx->sockid;
            ret = mtcp_epoll_ctl(ctx->worker->mctx, ctx->worker->ep, MTCP_EPOLL_CTL_MOD, ctx->sockid, &evctl);
            if (ret < 0) {
                perror("epoll_ctl");
                exit(1);
            }
        }
        UPDATE_STATE(ctx, STATE_WAIT_FOR_RECV);
    }
    
    return len;
}
Beispiel #2
0
static void new_connection(struct ctx *ctx)
{
	int ret;
    struct mtcp_epoll_event evctl;
    
    ctx->sockid = mtcp_socket(ctx->worker->mctx, AF_INET, MTCP_SOCK_STREAM, 0);
	if (ctx->sockid < 0) {
		perror("socket");
		exit(1);
	}
    
	ret = mtcp_setsock_nonblock(ctx->worker->mctx, ctx->sockid);
    if (ret < 0) {
        fprintf(stderr, "Error: Failed to make socket nonblocking on core %d\n", ctx->worker->cpu);
        exit(1);
    }
    
    ret = mtcp_connect(ctx->worker->mctx, ctx->sockid, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (ret < 0 && errno != EINPROGRESS) {
		ctx->sockid = -1;
        UPDATE_STATE(ctx, STATE_IDLE);
		LOG_ERROR(ctx->worker, ERRSOURCE_CONNECT, errno);
		return;
	}
	
	evctl.events = MTCP_EPOLLOUT | MTCP_EPOLLHUP | MTCP_EPOLLRDHUP;
    evctl.data.sockid = ctx->sockid;
    ret = mtcp_epoll_ctl(ctx->worker->mctx, ctx->worker->ep, MTCP_EPOLL_CTL_ADD, ctx->sockid, &evctl);
    if (ret < 0) {
        perror("epoll_ctl");
        exit(1);
    }
    
    UPDATE_STATE(ctx, STATE_CONNECTING);
    
    if (ctx->worker->sctx_map[ctx->sockid]) {
        fprintf(stderr, "Error: Replacing existing socket on core %d\n", ctx->worker->cpu);
        exit(1);
    }
    
    ctx->worker->sctx_map[ctx->sockid] = ctx;
    ctx->messages_left = messages_per_connection - 1;
}
QList<GObject*> DatabaseConnectionFormat::getObjects(U2Dbi* dbi, U2OpStatus &os) {
    QList<GObject*> resultList;

    QHash<U2DataId, QString> object2Name = dbi->getObjectDbi()->getObjectNames(0, U2DbiOptions::U2_DBI_NO_LIMIT, os);
    CHECK_OP(os, resultList);

    int progressCounter = 0;
    const int objectCount = object2Name.size();
    Q_UNUSED(progressCounter);
    Q_UNUSED(objectCount);
    const U2DbiRef dbiRef = dbi->getDbiRef();

    foreach (const U2DataId &id, object2Name.keys()) {
        UPDATE_STATE();
        GObject *obj = GObjectUtils::createObject(dbiRef, id, object2Name.value(id));
        if (NULL != obj) {
            resultList << obj;
        }
    }

    return resultList;
}
Beispiel #4
0
static int mtcp_write_handler(struct ctx *ctx)
{
    struct mtcp_epoll_event evctl;
    int ret;
    
    if (ctx->state == STATE_CONNECTING) {
        ctx->worker->total_connections++;
		ctx->worker->active_connections++;
    }
    
    write_echo_message(ctx);
    
    evctl.events = MTCP_EPOLLIN | MTCP_EPOLLHUP | MTCP_EPOLLRDHUP;
    evctl.data.sockid = ctx->sockid;
    ret = mtcp_epoll_ctl(ctx->worker->mctx, ctx->worker->ep, MTCP_EPOLL_CTL_MOD, ctx->sockid, &evctl);
    if (ret < 0) {
        perror("epoll_ctl");
        exit(1);
    }
    
    UPDATE_STATE(ctx, STATE_WAIT_FOR_RECV);
    
    return 0;
}
Beispiel #5
0
static void mtcp_error_handler(struct ctx *ctx)
{
    close_mtcp_socket(ctx);
    UPDATE_STATE(ctx, STATE_IDLE);
    LOG_ERROR(ctx->worker, ERRSOURCE_EVENT_ERROR, errno);
}