int membt_good( struct mem_list *list, unsigned long index )
{
if( index < 0 || index >= list->peak_count ){
return !!(NULL);
}
assert( index >= 0 && index < list->peak_count );
unsigned long offset = GET_NEED_COUNT(index + 1, list->step_count) - 1;
return ( !!list->ptr_slot[ offset ] );
}
struct mem_list *membt_init( int type_size, unsigned long peak_count )
{
struct mem_list *list = calloc(1, sizeof(struct mem_list));
assert( list );
printf("\x1B[0;32mPEAK_COUNT\t=\t\x1B[1;31m%zu\n\x1B[m", peak_count);
unsigned long page_size = getpagesize();
unsigned long bath_size = page_size * MEM_STEP_PAGE_COUNT;
unsigned long step_count = bath_size / type_size;
list->type_size = type_size;
list->peak_count = peak_count;
list->step_count = step_count;
list->ptr_slot = calloc( GET_NEED_COUNT(peak_count, step_count), sizeof(uintptr_t *) );
assert( list->ptr_slot );
return list;
}
char *ldb_values(struct _leveldb_stuff *ldbs, const char *ptn, size_t ptn_len, int *size)
{
char *err = NULL;
char *result = NULL;
char *p_dst = NULL;
char *p_key = NULL;
char *p_value = NULL;
size_t klen = 0;
size_t vlen = 0;
int index = 0;
int i, j, z = 0;
struct kv_list list = { 0 };
struct some_kv *p_new, *p_old, *p_tmp = NULL;
leveldb_iterator_t* iter = leveldb_create_iterator(ldbs->db, ldbs->roptions);
leveldb_iterator_t* iter_save = iter;
if (!!leveldb_iter_valid(iter)) {/* first use it is invalid */
fprintf(stderr, "%s:%d: this iter is valid already!\n", __FILE__, __LINE__);
*size = -1;
return NULL ;
}
leveldb_iter_seek_to_first(iter);
p_old = p_new = &list.head;
while (leveldb_iter_valid(iter)) {
/* parse kv */
p_key = (char *) leveldb_iter_key(iter, &klen);
log_debug("%p iter key = %s, klen = %ld\n", p_key, p_key, klen);
p_value = (char *) leveldb_iter_value(iter, &vlen);
leveldb_iter_get_error(iter, &err);
if (err) {
goto FAIL_ITER_PARSE;
}
if (!string_match_len(ptn, ptn_len, p_value, vlen, 0)) {
leveldb_iter_next(iter);
continue;
}
/* save parse */
list.count++;/* kv counts */
list.klens += klen;
list.knubs += get_number_len(klen);
index = list.count % SOME_KV_NODES_COUNT;
if ((list.count / SOME_KV_NODES_COUNT >= 1) && (index == 1)) {
/* new store */
p_new = malloc(sizeof(struct some_kv));
if (p_new == NULL ) {
/* free store */
index = GET_NEED_COUNT( list.count, SOME_KV_NODES_COUNT );
p_tmp = &list.head;
for (i = 0, z = list.count - 1; (i < index) && (p_tmp != NULL ); i++ ) {
for (j = 0; (j < SOME_KV_NODES_COUNT) && (z > 0); j++, z--) {
free(p_tmp->nodes[j].key);
}
p_old = p_tmp;
p_tmp = p_tmp->next;
if (p_old != &list.head) {
free(p_old);
}
}
goto FAIL_MEMORY;
}
memset(p_new, 0, sizeof(struct some_kv));
p_old->next = p_new;
p_new->prev = p_old;
p_old = p_new;
}
/*
* fix bug: index is error if list.count = n * SOME_KV_NODES_COUNT(1024),
* SOME_KV_NODES_COUNT = 1024, n > 0.
*/
if (index == 0) {
index = SOME_KV_NODES_COUNT;
}
/* save key */
p_new->nodes[index - 1].klen = klen;
p_new->nodes[index - 1].key = malloc(GET_NEED_COUNT( klen, G_PAGE_SIZE ) * G_PAGE_SIZE);
memcpy(p_new->nodes[index - 1].key, p_key, klen);
/* find next */
leveldb_iter_next(iter);
}
/* create result */
if (list.count > 0) {
/* has members */
/* *2\r\n$5\r\nmykey\r\n$5\r\nmyval\r\n */
*size = strlen("*\r\n") + get_number_len(list.count) + strlen("$\r\n\r\n") * (list.count)
+ list.knubs + list.klens;
index = GET_NEED_COUNT( *size, G_PAGE_SIZE ) * G_PAGE_SIZE;
result = (char *) malloc(index);
if (result == NULL ) goto FAIL_MEMORY;
memset(result, 0, index);
log_debug("----->>>ALL SIZE IS %d, BUFF %p : LEN IS %d\n", *size, result, index);
/* split piece */
index = GET_NEED_COUNT( list.count, SOME_KV_NODES_COUNT );
p_tmp = &list.head;
sprintf(result, "*%d\r\n", list.count);
p_dst = result + strlen(result);
for (i = 0, z = list.count; (i < index) && (p_tmp != NULL ); i++ ) {
for (j = 0; (j < SOME_KV_NODES_COUNT) && (z > 0); j++, z--) {
p_dst = set_bulk(p_dst, p_tmp->nodes[j].key, p_tmp->nodes[j].klen);
free(p_tmp->nodes[j].key);
}
p_old = p_tmp;
p_tmp = p_tmp->next;
if (p_old != &list.head) {
free(p_old);
}
}
} else {
/* no members */
*size = 0;
}
leveldb_iter_destroy(iter_save);
return result;
FAIL_ITER_PARSE: fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, (err));
leveldb_free(err);
err = NULL;
leveldb_iter_destroy(iter);
*size = -1;
return NULL ;
FAIL_MEMORY: fprintf(stderr, "%s:%d: FAILED MALLOC !\n", __FILE__, __LINE__);
leveldb_iter_destroy(iter);
*size = -1;
return NULL ;
}
char *ldb_info(struct _leveldb_stuff *ldbs, int *size)
{
int cnt = 0;
*size = 0;
/* #server */
char svr[16] = "# Server:";
++cnt;
*size += strlen(svr) + get_number_len(strlen(svr));
/* tsdb version */
char vers[32] = TSDB_VERSION;
++cnt;
*size += strlen(vers) + get_number_len(strlen(vers));
/* os */
char os[64] = { 0 };
struct utsname name;
uname(&name);
sprintf(os, "os: %s %s %s", name.sysname, name.release, name.machine);
++cnt;
*size += strlen(os) + get_number_len(strlen(os));
/* pid */
char pid[32] = { 0 };
sprintf(pid, "process_id: %ld", (long) getpid());
++cnt;
*size += strlen(pid) + get_number_len(strlen(pid));
/* mode. */
char mode[32] = { 0 };
sprintf(mode, "mode: %s", LDB_READONLY_SWITCH ? "readonly" : "read/write");
++cnt;
*size += strlen(mode) + get_number_len(strlen(mode));
/* write_port */
char wport[32] = { 0 };
sprintf(wport, "write_port: %d", W_PORT);
++cnt;
*size += strlen(wport) + get_number_len(strlen(wport));
/* read_port */
char rport[32] = { 0 };
sprintf(rport, "read_port: %d", R_PORT);
++cnt;
*size += strlen(rport) + get_number_len(strlen(rport));
/* uptime_in_seconds */
char uptis[64] = { 0 };
time_t curtime;
time(&curtime);
sprintf(uptis, "uptime_in_seconds: %ld", (curtime - LDB_START_TIME));
++cnt;
*size += strlen(uptis) + get_number_len(strlen(uptis));
/* uptime_in_days */
char uptid[64] = { 0 };
sprintf(uptid, "uptime_in_days: %ld",
(curtime - LDB_START_TIME) / (24 * 3600));
++cnt;
*size += strlen(uptid) + get_number_len(strlen(uptid));
/* # Keyspace. */
char keyspace[32] = "\n# Keyspace:\nTODO";
++cnt;
*size += strlen(keyspace) + get_number_len(strlen(keyspace));
/* #LeveldbStatus: */
char ldbstat[32] = "\n# Leveldbstatus:";
++cnt;
*size += strlen(ldbstat) + get_number_len(strlen(ldbstat));
/* get property. */
char *property = leveldb_property_value(ldbs->db, "leveldb.stats");
++cnt;
*size += strlen(property) + get_number_len(strlen(property));
/* create result */
*size += strlen("*\r\n") + get_number_len(cnt) + strlen("$\r\n\r\n") * cnt;
int index = GET_NEED_COUNT( *size, G_PAGE_SIZE ) * G_PAGE_SIZE;
char *result = (char *) malloc(index);
char *ptr = NULL;
sprintf(result, "*%d\r\n", cnt);
/* #Server */
ptr = result + strlen(result);
ptr = set_bulk(ptr, svr, strlen(svr));
ptr = set_bulk(ptr, vers, strlen(vers));
ptr = set_bulk(ptr, os, strlen(os));
ptr = set_bulk(ptr, mode, strlen(mode));
ptr = set_bulk(ptr, pid, strlen(pid));
ptr = set_bulk(ptr, wport, strlen(wport));
ptr = set_bulk(ptr, rport, strlen(rport));
ptr = set_bulk(ptr, uptis, strlen(uptis));
ptr = set_bulk(ptr, uptid, strlen(uptid));
/* #Keyspace */
ptr = set_bulk(ptr, keyspace, strlen(keyspace));
/* #Leveldbstatus */
ptr = set_bulk(ptr, ldbstat, strlen(ldbstat));
ptr = set_bulk(ptr, property, strlen(property));
leveldb_free(property);
log_debug("%s\n", result);
return result;
}