示例#1
0
static int
nc_event_init(struct nc_event *event)
{
    struct nc_event_state *e_state;

    e_state = nc_alloc(sizeof(*e_state));
    if (e_state == NULL) {
        return -1;
    }
    e_state->events = nc_calloc(event->nevent, sizeof(struct epoll_event));
    if (e_state->events == NULL) {
        nc_free(e_state);
        return -1;
    }
    e_state->ep = epoll_create(event->nevent);
    if (e_state->ep < 0) {
        nc_free(e_state->events);
        nc_free(e_state);
        log_error("epoll create of size %d failed: %s", event->nevent, 
                strerror(errno));
        return -1;
    }
    log_debug(LOG_INFO, "e %d with nevent %d", e_state->ep, event->nevent);
    event->event_data = e_state;
    return 0;
}
示例#2
0
struct event_base *
event_base_create(int nevent, event_cb_t cb)
{
    struct event_base *evb;
    int status, kq;
    struct kevent *change, *event;

    ASSERT(nevent > 0);

    kq = kqueue();
    if (kq < 0) {
        log_error("kqueue failed: %s", strerror(errno));
        return NULL;
    }

    change = nc_calloc(nevent, sizeof(*change));
    if (change == NULL) {
        status = close(kq);
        if (status < 0) {
            log_error("close kq %d failed, ignored: %s", kq, strerror(errno));
        }
        return NULL;
    }

    event = nc_calloc(nevent, sizeof(*event));
    if (event == NULL) {
        nc_free(change);
        status = close(kq);
        if (status < 0) {
            log_error("close kq %d failed, ignored: %s", kq, strerror(errno));
        }
        return NULL;
    }

    evb = nc_alloc(sizeof(*evb));
    if (evb == NULL) {
        nc_free(change);
        nc_free(event);
        status = close(kq);
        if (status < 0) {
            log_error("close kq %d failed, ignored: %s", kq, strerror(errno));
        }
        return NULL;
    }

    evb->kq = kq;
    evb->change = change;
    evb->nchange = 0;
    evb->event = event;
    evb->nevent = nevent;
    evb->nreturned = 0;
    evb->nprocessed = 0;
    evb->cb = cb;

    log_debug(LOG_INFO, "kq %d with nevent %d", evb->kq, evb->nevent);

    return evb;
}
示例#3
0
static struct conf *
conf_open(char *filename)
{
    rstatus_t status;
    struct conf *cf;
    FILE *fh;

    fh = fopen(filename, "r");
    if (fh == NULL) {
        log_error("conf: failed to open configuration '%s': %s", filename,
                  strerror(errno));
        return NULL;
    }

    cf = nc_alloc(sizeof(*cf));
    if (cf == NULL) {
        fclose(fh);
        return NULL;
    }

    status = array_init(&cf->arg, CONF_DEFAULT_ARGS, sizeof(struct string));
    if (status != NC_OK) {
        nc_free(cf);
        fclose(fh);
        return NULL;
    }

    status = array_init(&cf->pool, CONF_DEFAULT_POOL, sizeof(struct conf_pool));
    if (status != NC_OK) {
        array_deinit(&cf->arg);
        nc_free(cf);
        fclose(fh);
        return NULL;
    }

    cf->fname = filename;
    cf->fh = fh;
    cf->depth = 0;
    /* parser, event, and token are initialized later */
    cf->seq = 0;
    cf->valid_parser = 0;
    cf->valid_event = 0;
    cf->valid_token = 0;
    cf->sound = 0;
    cf->parsed = 0;
    cf->valid = 0;

    log_debug(LOG_VVERB, "opened conf '%s'", filename);

    return cf;
}
示例#4
0
static void
nc_event_deinit(struct nc_event *event)
{
    int status;
    struct nc_event_state *e_state = event->event_data;

    ASSERT(e_state->ep >= 0);

    status = close(e_state->ep);
    if (status < 0) {
        log_error("close e %d failed, ignored: %s", e_state->ep, 
                strerror(errno));
    }
    nc_free(e_state->events);
    nc_free(e_state);
}
示例#5
0
static void *thread_entry(void *arg)
{
    int rv;
    store_client_t *sc = (store_client_t *)arg;
    net_client_t *nc = sc->nc;
    void *msg;uint32_t len;

    while(!sc->stop_daemon)
    {
	rv = nc_recvmsg(nc,&msg,&len,MS_PER_SECOND/4);
	if(rv < 0)
	    continue;
	if(rv == 0)
	{
	    process_msg(msg,len);
	    //process msg
	    nc_free(nc,msg);
	}
	if(rv == 1)
	{
	    //disconnect
	}
    }
    return NULL;
}
示例#6
0
void
sentinel_deinit(struct server *sentinel)
{
    if (sentinel == NULL) {
        return;
    }

    ASSERT(TAILQ_EMPTY(&sentinel->s_conn_q) && sentinel->ns_conn_q == 0);

    string_deinit(&sentinel->name);
    string_deinit(&sentinel->pname);
    if (sentinel->addr != NULL) {
        nc_free(sentinel->addr);
    }
    nc_free(sentinel);
}
示例#7
0
void
server_pool_deinit(struct array *server_pool)
{
    uint32_t i, npool;

    for (i = 0, npool = array_n(server_pool); i < npool; i++) {
        struct server_pool *sp;

        sp = array_pop(server_pool);
        ASSERT(sp->p_conn == NULL);
        ASSERT(TAILQ_EMPTY(&sp->c_conn_q) && sp->nc_conn_q == 0);

        if (sp->continuum != NULL) {
            nc_free(sp->continuum);
            sp->ncontinuum = 0;
            sp->nserver_continuum = 0;
            sp->nlive_server = 0;
        }

        server_deinit(&sp->server);

        log_debug(LOG_DEBUG, "deinit pool %"PRIu32" '%.*s'", sp->idx,
                  sp->name.len, sp->name.data);
    }

    array_deinit(server_pool);

    log_debug(LOG_DEBUG, "deinit %"PRIu32" pools", npool);
}
示例#8
0
文件: nc_conf.c 项目: idning/ccl
/**
 * eval a statement, leave value in the stack
 * like luaL_xxx functions, return 0 on success.
 */
static int
_lua_eval(lua_State *L, const char *expr)
{
    char       *buf;
    int         status;

    buf = nc_alloc(strlen(expr) + sizeof("return "));
    strcpy(buf, "return ");
    strcat(buf, expr);
    status = luaL_loadbuffer(L, buf, strlen(buf), "eval");
    if (status) {
        log_stderr("nc_conf: error on loadbuffer: %s", lua_tostring(L, -1));
        lua_pop(L, 1);
        goto out;
    }

    status = lua_pcall(L, 0, 1, 0);
    if (status) {
        log_stderr("nc_conf: error on lua_pcall: %s", lua_tostring(L, -1));
        lua_pop(L, 1);
        goto out;
    }

    if (lua_isnil(L, -1)) {
        log_stderr("nc_conf: value is nil: %s", expr);
        status = NC_ERROR;
    }
    status = NC_OK;

out:
    nc_free(buf);
    return status;
}
示例#9
0
文件: ndb_cursor.c 项目: idning/ndb
cursor_t *
cursor_create(store_t *store)
{
    cursor_t *cursor;

    cursor = nc_alloc(sizeof(*cursor));
    if (cursor == NULL) {
        return NULL;
    }

    cursor->iter = leveldb_create_iterator(store->db, store->roptions);
    if (cursor->iter == NULL) {
        nc_free(cursor);
        return NULL;
    }

    leveldb_iter_seek_to_first(cursor->iter);

    cursor->id = g_cursor_id++;
    cursor->owner = store;

    ncursor++;
    STAILQ_INSERT_HEAD(&cursorq, cursor, next);

    return cursor;
}
示例#10
0
struct evcenter *
event_init(int size)
{
    int status, ep;
    struct kevent *event;
    struct fired_event *fired_events;
    struct evcenter *center;

    center = nc_zalloc(sizeof(struct evcenter));
    if (center == NULL) {
        log_error("center create failed: %s", strerror(errno));
        return NULL;
    }

    ep = kqueue();
    if (ep < 0) {
        nc_free(center);
        log_error("kqueue create failed: %s", strerror(errno));
        return NULL;
    }

    event = nc_calloc(size, sizeof(struct kevent));
    fired_events = nc_calloc(size, sizeof(struct fired_event));
    if (event == NULL || fired_events == NULL) {
        status = close(ep);
        nc_free(center);
        if (event != NULL)
            nc_free(event);
        if (fired_events != NULL)
            nc_free(fired_events);
        if (status < 0) {
            log_error("close e %d failed, ignored: %s", ep, strerror(errno));
        }
        return NULL;
    }

    center->ep = ep;
    center->event = event;
    center->nevent = size;
    center->fired_events = fired_events;

    log_debug(LOG_INFO, "e %d with nevent %d", center->ep,
              center->nevent);

    return center;
}
示例#11
0
void
evbase_destroy(struct evbase *evb)
{
    int status;

    if (evb == NULL) return;

    ASSERT(evb->ep >= 0);

    nc_free(evb->event);

    status = close(evb->ep);
    if (status < 0) {
        log_error("close e %d failed, ignored: %s", evb->ep, strerror(errno));
    }
    nc_free(evb);
}
示例#12
0
void
evbase_destroy(struct evbase *evb)
{
    int status;

    if (evb == NULL) return;

    ASSERT(evb->kq >= 0);

    nc_free(evb->changes);
    nc_free(evb->kevents);

    status = close(evb->kq);
    if (status < 0) {
        log_error("close kq %d failed, ignored: %s", evb->kq, strerror(errno));
    }
    nc_free(evb);
}
示例#13
0
static void
stats_destroy_buf(struct stats *st)
{
    if (st->buf.size != 0) {
        ASSERT(st->buf.data != NULL);
        nc_free(st->buf.data);
        st->buf.size = 0;
    }
}
示例#14
0
void
stats_destroy(struct stats *st)
{
    stats_stop_aggregator(st);
    stats_pool_unmap(&st->sum);
    stats_pool_unmap(&st->shadow);
    stats_pool_unmap(&st->current);
    stats_destroy_buf(st);
    nc_free(st);
}
示例#15
0
文件: ndb_cursor.c 项目: idning/ndb
rstatus_t
cursor_destory(cursor_t *cursor)
{
    leveldb_iter_destroy(cursor->iter);
    STAILQ_REMOVE(&cursorq, cursor, cursor_s, next);
    nc_free(cursor);
    ncursor--;

    return NC_OK;
}
示例#16
0
void
btpd_name_connect_cancel(struct nameconn *nc)
{
    if (nc->state == NC_AI)
        btpd_addrinfo_cancel(nc->ai_handle);
    else {
        btpd_ev_del(&nc->write_ev);
        closesocket(nc->sd);
    }
    nc_free(nc);
}
示例#17
0
static void
core_ctx_destroy(struct context *ctx)
{
    log_debug(LOG_VVERB, "destroy ctx %p id %"PRIu32"", ctx, ctx->id);
    proxy_deinit(ctx);
    server_pool_disconnect(ctx);
    event_deinit(ctx);
    stats_destroy(ctx->stats);
    server_pool_deinit(&ctx->pool);
    conf_destroy(ctx->cf);
    nc_free(ctx);
}
示例#18
0
/* Free a slow log entry. The argument is void so that the prototype of this
 * function matches the one of the 'free' method of adlist.c.
 *
 * This function will take care to release all the retained object. */
static void slowlog_free_entry(slowlog_entry *se) {
    if (se->keys) {
        struct string *key;
        while (array_n(se->keys) > 0) {
            key = array_pop(se->keys);
            string_deinit(key);
        }
        
        array_destroy(se->keys);
    }
    
    nc_free(se);
}
示例#19
0
void
event_base_destroy(struct event_base *evb)
{
    int status;

    if (evb == NULL) {
        return;
    }

    ASSERT(evb->kq > 0);

    nc_free(evb->change);
    nc_free(evb->event);

    status = close(evb->kq);
    if (status < 0) {
        log_error("close kq %d failed, ignored: %s", evb->kq, strerror(errno));
    }
    evb->kq = -1;

    nc_free(evb);
}
示例#20
0
static void
mbuf_free(struct mbuf *mbuf)
{
    uint8_t *buf;

    log_debug(LOG_VVERB, "put mbuf %p len %d", mbuf, mbuf->last - mbuf->pos);

    ASSERT(STAILQ_NEXT(mbuf, next) == NULL);
    ASSERT(mbuf->magic == MBUF_MAGIC);

    buf = (uint8_t *)mbuf - mbuf_offset;
    nc_free(buf);
}
示例#21
0
struct evbase * 
evbase_create(int nevent, void (*callback_fp)(void *, uint32_t))
{

    struct evbase *evb;
    int status, ep;
    struct epoll_event *event;

    if (nevent <= 0) {
        log_error("nevent has to be positive %d", nevent);
        return NULL;
    }

    ep = epoll_create(nevent);
    if (ep < 0) {
        log_error("epoll create of size %d failed: %s", nevent, strerror(errno));
        return NULL;
    }

    event = nc_calloc(nevent, sizeof(*event));
    if (event == NULL) {
        status = close(ep);
        if (status < 0) {
            log_error("close e %d failed, ignored: %s", ep, strerror(errno));
        }
        return NULL;
    }

    evb = nc_alloc(sizeof(*evb));
    if (evb == NULL) {
        nc_free(event);
        status = close(ep);
        if (status < 0) {
            log_error("close e %d failed, ignored: %s", ep, strerror(errno));
        }
        return NULL;

    }

    evb->nevent = nevent;
    evb->ep = ep;
    evb->event = event;
    evb->callback_fp = callback_fp;

    log_debug(LOG_INFO, "e %d with nevent %d", evb->ep,
              evb->nevent);

    return evb;
}
示例#22
0
void
event_deinit(struct evcenter *center)
{
    int status;

    ASSERT(center->ep >= 0);

    nc_free(center->event);

    status = close(center->ep);
    if (status < 0) {
        log_error("close e %d failed, ignored: %s", center->ep, strerror(errno));
    }
    center->ep = -1;
}
示例#23
0
void
conf_destroy(struct conf *cf)
{
    while (array_n(&cf->arg) != 0) {
        conf_pop_scalar(cf);
    }
    array_deinit(&cf->arg);

    while (array_n(&cf->pool) != 0) {
        conf_pool_deinit(array_pop(&cf->pool));
    }
    array_deinit(&cf->pool);

    nc_free(cf);
}
示例#24
0
文件: nemu.c 项目: wareya/gzrt
int main ( int argc, char ** argv )
{
    GtkWidget * w;
    
    nc_load_codes( argv[1] );
    nc_free();
    nc_load_codes( ini );
    nc_rebuild_ini();
    
    gtk_init( &argc, &argv );
    
    w = gtk_window_new( GTK_WINDOW_TOPLEVEL );
    gtk_container_add( GTK_CONTAINER(w), nc_display_create() );
    gtk_widget_show_all( w );
    
    gtk_main();
    
    return 0;
}
示例#25
0
struct event_base *
event_base_create(int nevent, event_cb_t cb)
{
    struct event_base *evb;
    int status, ep;
    struct epoll_event *event;

    ASSERT(nevent > 0);

    ep = epoll_create(nevent);
    if (ep < 0) {
        log_error("epoll create of size %d failed: %s", nevent, strerror(errno));
        return NULL;
    }

    event = nc_calloc(nevent, sizeof(*event));
    if (event == NULL) {
        status = close(ep);
        if (status < 0) {
            log_error("close e %d failed, ignored: %s", ep, strerror(errno));
        }
        return NULL;
    }

    evb = nc_alloc(sizeof(*evb));
    if (evb == NULL) {
        nc_free(event);
        status = close(ep);
        if (status < 0) {
            log_error("close e %d failed, ignored: %s", ep, strerror(errno));
        }
        return NULL;
    }

    evb->ep = ep;
    evb->event = event;
    evb->nevent = nevent;
    evb->cb = cb;

    log_debug(LOG_INFO, "e %d with nevent %d", evb->ep, evb->nevent);

    return evb;
}
示例#26
0
文件: nc_evport.c 项目: idning/ndb
struct event_base *
event_base_create(int nevent, event_cb_t cb)
{
    struct event_base *evb;
    int status, evp;
    port_event_t *event;

    ASSERT(nevent > 0);

    evp = port_create();
    if (evp < 0) {
        log_error("port create failed: %s", strerror(errno));
        return NULL;
    }

    event = nc_calloc(nevent, sizeof(*event));
    if (event == NULL) {
        status = close(evp);
        if (status < 0) {
            log_error("close evp %d failed, ignored: %s", evp, strerror(errno));
        }
        return NULL;
    }

    evb = nc_alloc(sizeof(*evb));
    if (evb == NULL) {
        nc_free(event);
        status = close(evp);
        if (status < 0) {
            log_error("close evp %d failed, ignored: %s", evp, strerror(errno));
        }
        return NULL;
    }

    evb->evp = evp;
    evb->event = event;
    evb->nevent = nevent;
    evb->cb = cb;

    log_info("evp %d with nevent %d", evb->evp, evb->nevent);

    return evb;
}
示例#27
0
/* Copy a netCDF file, changing cmode if desired. */
static
int copy_file(char *file_name_in, char *file_name_out, int cmode_out,
	      int *chunking, int *deflate)
{
   int ncid_in, ncid_out;
   int natts, nvars, ndims, unlimdimid;
   char name[NC_MAX_NAME + 1];
   size_t len;
   int a, v, d;

   if (nc_open(file_name_in, NC_NOWRITE, &ncid_in)) ERR;
   if (nc_create(file_name_out, cmode_out, &ncid_out)) ERR;
      
   if (nc_inq(ncid_in, &ndims, &nvars, &natts, &unlimdimid)) ERR;

   /* Copy dims. */
   for (d = 0; d < ndims; d++)
   {
      if (nc_inq_dim(ncid_in, d, name, &len)) ERR;
      if (nc_def_dim(ncid_out, name, len, NULL)) ERR;
   }

   /* Copy global atts. */
   for (a = 0; a < natts; a++)
   {
      if (nc_inq_attname(ncid_in, NC_GLOBAL, a, name)) ERR;
      if (nc_copy_att(ncid_in, NC_GLOBAL, name, ncid_out, NC_GLOBAL)) ERR;
   }

   /* Copy the variable metadata. */
   for (v = 0; v < nvars; v++)
   {
      char name[NC_MAX_NAME + 1];
      char att_name[NC_MAX_NAME + 1];
      nc_type xtype;
      int ndims, dimids[NC_MAX_VAR_DIMS], natts;
      int varid_out;
      int a;
      int retval = NC_NOERR;

      /* Learn about this var. */
      if ((retval = nc_inq_var(ncid_in, v, name, &xtype, &ndims, dimids, &natts)))
	 return retval;

      /* Create the output var. */
      if (nc_def_var(ncid_out, name, xtype, ndims, dimids, &varid_out)) ERR;

      /* Except for 1D vars, sent chunking and compression. */
      if (ndims != 1)
      {
	 if (chunking)
	    if (nc_def_var_chunking(ncid_out, v, NC_CHUNKED, chunking)) ERR;
	 if (deflate)
	    if (nc_def_var_deflate(ncid_out, v, NC_NOSHUFFLE, *deflate, *deflate)) ERR;
      }

      /* Copy the attributes. */
      for (a=0; a<natts; a++)
      {
	 if (nc_inq_attname(ncid_in, v, a, att_name)) ERR;
	 if (nc_copy_att(ncid_in, v, att_name, ncid_out, varid_out)) ERR;
      }
   }

   /* Copy the variable data. */
   for (v = 0; v < nvars; v++)
   {
      char name[NC_MAX_NAME + 1];
      nc_type xtype;
      int ndims, dimids[NC_MAX_VAR_DIMS], natts, real_ndims;
      int d;
      void *data = NULL;
      size_t *count = NULL, *start = NULL;
      size_t reclen = 1;
      size_t *dimlen = NULL;
      int retval = NC_NOERR;
      size_t type_size;
      char type_name[NC_MAX_NAME+1];

      /* Learn about this var. */
      if ((retval = nc_inq_var(ncid_in, v, name, &xtype, &ndims, dimids, &natts)))
	 return retval;

      /* Later on, we will need to know the size of this type. */
      if ((retval = nc_inq_type(ncid_in, xtype, type_name, &type_size)))
	 return retval;
      LOG((3, "type %s has size %d", type_name, type_size));

      /* Allocate memory for our start and count arrays. If ndims = 0
	 this is a scalar, which I will treat as a 1-D array with one
	 element. */
      real_ndims = ndims ? ndims : 1;
      if (!(start = nc_malloc(real_ndims * sizeof(size_t))))
	 BAIL(NC_ENOMEM);
      if (!(count = nc_malloc(real_ndims * sizeof(size_t))))
	 BAIL(NC_ENOMEM);

      /* The start array will be all zeros, except the first element,
	 which will be the record number. Count will be the dimension
	 size, except for the first element, which will be one, because
	 we will copy one record at a time. For this we need the var
	 shape. */
      if (!(dimlen = nc_malloc(real_ndims * sizeof(size_t))))
	 BAIL(NC_ENOMEM);

      /* Find out how much data. */
      for (d=0; d<ndims; d++)
      {
	 if ((retval = nc_inq_dimlen(ncid_in, dimids[d], &dimlen[d])))
	    BAIL(retval);
	 LOG((4, "nc_copy_var: there are %d data", dimlen[d]));
      }

      /* If this is really a scalar, then set the dimlen to 1. */
      if (ndims == 0)
	 dimlen[0] = 1;

      for (d=0; d<real_ndims; d++)
      {
	 start[d] = 0;
	 count[d] = d ? dimlen[d] : 1;
	 if (d) reclen *= dimlen[d];
      }

      /* If there are no records, we're done. */
      if (!dimlen[0])
	 goto exit;

      /* Allocate memory for one record. */
      if (!(data = nc_malloc(reclen * type_size)))
	 return NC_ENOMEM;
   
      /* Copy the var data one record at a time. */
      for (start[0]=0; !retval && start[0]<(size_t)dimlen[0]; start[0]++)
      {
	 if (nc_get_vara(ncid_in, v, start, count, data)) ERR;
	 if (nc_put_vara(ncid_out, v, start, count, data)) ERR;
      }
    
     exit:
      if (data) nc_free(data);
      if (dimlen) nc_free(dimlen);
      if (start) nc_free(start);
      if (count) nc_free(count);

   }

   if (nc_close(ncid_in)) ERR;
   if (nc_close(ncid_out)) ERR;

   return NC_NOERR;
}
示例#28
0
static struct context *
core_ctx_create(struct instance *nci)
{
    rstatus_t status;
    struct context *ctx;
    struct conn *sentinel_conn;

    ctx = nc_alloc(sizeof(*ctx));
    if (ctx == NULL) {
        return NULL;
    }
    ctx->id = ++ctx_id;
    ctx->cf = NULL;
    ctx->stats = NULL;
    array_null(&ctx->pool);
    ctx->ep = -1;
    ctx->nevent = EVENT_SIZE_HINT;
    ctx->max_timeout = nci->stats_interval;
    ctx->timeout = ctx->max_timeout;
    ctx->event = NULL;
    ctx->server_reconnect_interval = nci->server_reconnect_interval;
    ctx->whitelist = nci->whitelist;

    /* parse and create configuration */
    ctx->cf = conf_create(nci->conf_filename);
    if (ctx->cf == NULL) {
        nc_free(ctx);
        return NULL;
    }

    /* initialize server pool from configuration */
    status = server_pool_init(&ctx->pool, &ctx->cf->pool, ctx);
    if (status != NC_OK) {
        conf_destroy(ctx->cf);
        nc_free(ctx);
        return NULL;
    }

    /* initialize sentinel server */
    ctx->sentinel = sentinel_init(nci->sentinel_port, nci->sentinel_addr);
    if (ctx->sentinel == NULL) {
        server_pool_deinit(&ctx->pool);
        conf_destroy(ctx->cf);
        nc_free(ctx);
        return NULL;
    }

    /* create stats per server pool */
    ctx->stats = stats_create(nci->stats_port, nci->stats_addr, nci->stats_interval,
                              nci->hostname, &ctx->pool);
    if (ctx->stats == NULL) {
        sentinel_deinit(ctx->sentinel);
        server_pool_deinit(&ctx->pool);
        conf_destroy(ctx->cf);
        nc_free(ctx);
        return NULL;
    }

    /* initialize event handling for client, proxy and server */
    status = event_init(ctx, EVENT_SIZE_HINT);
    if (status != NC_OK) {
        stats_destroy(ctx->stats);
        sentinel_deinit(ctx->sentinel);
        server_pool_deinit(&ctx->pool);
        conf_destroy(ctx->cf);
        nc_free(ctx);
        return NULL;
    }

    /* preconnect? servers in server pool */
    status = server_pool_preconnect(ctx);
    if (status != NC_OK) {
        server_pool_disconnect(ctx);
        event_deinit(ctx);
        stats_destroy(ctx->stats);
        sentinel_deinit(ctx->sentinel);
        server_pool_deinit(&ctx->pool);
        conf_destroy(ctx->cf);
        nc_free(ctx);
        return NULL;
    }

    /* initialize sentinel server conn */
    sentinel_conn = sentinel_connect(ctx);
    if (sentinel_conn == NULL) {
        server_pool_disconnect(ctx);
        event_deinit(ctx);
        stats_destroy(ctx->stats);
        sentinel_deinit(ctx->sentinel);
        server_pool_deinit(&ctx->pool);
        conf_destroy(ctx->cf);
        nc_free(ctx);
    }

    /* initialize proxy per server pool */
    status = proxy_init(ctx);
    if (status != NC_OK) {
        sentinel_conn->close(ctx, sentinel_conn);
        server_pool_disconnect(ctx);
        event_deinit(ctx);
        stats_destroy(ctx->stats);
        sentinel_deinit(ctx->sentinel);
        server_pool_deinit(&ctx->pool);
        conf_destroy(ctx->cf);
        nc_free(ctx);
        return NULL;
    }

    log_debug(LOG_VVERB, "created ctx %p id %"PRIu32"", ctx, ctx->id);

    return ctx;
}
示例#29
0
/*
 * read the comment in proto/nc_redis.c
 */
static rstatus_t
memcache_fragment_retrieval(struct msg *r, uint32_t ncontinuum,
                            struct msg_tqh *frag_msgq,
                            uint32_t key_step)
{
    struct mbuf *mbuf;
    struct msg **sub_msgs;
    uint32_t i;
    rstatus_t status;

    sub_msgs = nc_zalloc(ncontinuum * sizeof(*sub_msgs));
    if (sub_msgs == NULL) {
        return NC_ENOMEM;
    }

    ASSERT(r->frag_seq == NULL);
    r->frag_seq = nc_alloc(array_n(r->keys) * sizeof(*r->frag_seq));
    if (r->frag_seq == NULL) {
        nc_free(sub_msgs);
        return NC_ENOMEM;
    }

    mbuf = STAILQ_FIRST(&r->mhdr);
    mbuf->pos = mbuf->start;

    /*
     * This code is based on the assumption that 'gets ' is located
     * in a contiguous location.
     * This is always true because we have capped our MBUF_MIN_SIZE at 512 and
     * whenever we have multiple messages, we copy the tail message into a new mbuf
     */
    for (; *(mbuf->pos) != ' ';) {          /* eat get/gets  */
        mbuf->pos++;
    }
    mbuf->pos++;

    r->frag_id = msg_gen_frag_id();
    r->nfrag = 0;
    r->frag_owner = r;

    for (i = 0; i < array_n(r->keys); i++) {        /* for each  key */
        struct msg *sub_msg;
        struct keypos *kpos = array_get(r->keys, i);
        uint32_t idx = msg_backend_idx(r, kpos->start, kpos->end - kpos->start);

        if (sub_msgs[idx] == NULL) {
            sub_msgs[idx] = msg_get(r->owner, r->request, r->redis);
            if (sub_msgs[idx] == NULL) {
                nc_free(sub_msgs);
                return NC_ENOMEM;
            }
        }
        r->frag_seq[i] = sub_msg = sub_msgs[idx];

        sub_msg->narg++;
        status = memcache_append_key(sub_msg, kpos->start, kpos->end - kpos->start);
        if (status != NC_OK) {
            nc_free(sub_msgs);
            return status;
        }
    }

    for (i = 0; i < ncontinuum; i++) {     /* prepend mget header, and forward it */
        struct msg *sub_msg = sub_msgs[i];
        if (sub_msg == NULL) {
            continue;
        }

        /* prepend get/gets */
        if (r->type == MSG_REQ_MC_GET) {
            status = msg_prepend(sub_msg, (uint8_t *)"get ", 4);
        } else if (r->type == MSG_REQ_MC_GETS) {
            status = msg_prepend(sub_msg, (uint8_t *)"gets ", 5);
        }
        if (status != NC_OK) {
            nc_free(sub_msgs);
            return status;
        }

        /* append \r\n */
        status = msg_append(sub_msg, (uint8_t *)CRLF, CRLF_LEN);
        if (status != NC_OK) {
            nc_free(sub_msgs);
            return status;
        }

        sub_msg->type = r->type;
        sub_msg->frag_id = r->frag_id;
        sub_msg->frag_owner = r->frag_owner;

        TAILQ_INSERT_TAIL(frag_msgq, sub_msg, m_tqe);
        r->nfrag++;
    }

    nc_free(sub_msgs);
    return NC_OK;
}
示例#30
0
struct evbase *
evbase_create(int nevent, void (*callback_fp)(void *, uint32_t))
{

    struct evbase *evb;
    int status, kq;
    struct kevent *changes, *kevents;

    if (nevent <= 0) {
        log_error("nevent has to be positive %d", nevent);
        return NULL;
    }

    /* Initialize the kernel queue */
    if ((kq = kqueue()) == -1) {
        log_error("kernel queue create failed: %s", kq, strerror(errno));
        return NULL;
    }

    changes = nc_calloc(nevent, sizeof(*changes));
    if (changes == NULL) {
        status = close(kq);
        if (status < 0) {
            log_error("close kq %d failed, ignored: %s", kq, strerror(errno));
        }
        return NULL;
    }

    kevents = nc_calloc(nevent, sizeof(*kevents));
    if (kevents == NULL) {
        nc_free(changes);
        status = close(kq);
        if (status < 0) {
            log_error("close kq %d failed, ignored: %s", kq, strerror(errno));
        }
        return NULL;
    }

    evb = (struct evbase *) nc_alloc(sizeof(*evb));
    if (evb == NULL) {
        nc_free(changes);
        nc_free(kevents);
        status = close(kq);
        if (status < 0) {
            log_error("close kq %d failed, ignored: %s", kq, strerror(errno));
        }
        return NULL;
    }

    evb->kq = kq;
    evb->changes = changes;
    evb->kevents  = kevents;
    evb->nevent = nevent;
    evb->callback_fp = callback_fp;
    evb->n_changes = 0;

    log_debug(LOG_INFO, "kq %d with nevent %d", evb->kq,
              evb->nevent);

    return evb;
}