int32_t process_client_message(struct mile_message_header* msg_head,
struct data_buffer* rbuf, struct data_buffer* sbuf) {
int32_t result_code = MILE_RETURN_SUCCESS;
MEM_POOL_PTR mem_pool;
void* packet;
struct slave_sync_res *binlog_res;
switch (msg_head->message_type) {
case MT_CD_EXE_GET_LOAD_THRESHOLD: {
log_debug("get get_load_threshold command");
double load = g_load_threshold;
gen_dc_get_load_threshold_packet(load, msg_head, sbuf);
}
break;
case MT_CD_EXE_SET_LOAD_THRESHOLD: {
log_debug("get set_load_threshold command");
double old_load = g_load_threshold;
mem_pool = mem_pool_init(KB_SIZE);
struct set_load_threshold_packet *p = parse_set_load_threshold_packet(
mem_pool, rbuf);
g_load_threshold = p->value;
log_info(
"change os overloading threshold from %g to %g", old_load, g_load_threshold);
gen_dc_set_load_threshold_packet(old_load, msg_head, sbuf);
mem_pool_destroy(mem_pool);
}
break;
default:
result_code = -1;
break;
}
return result_code;
}
void test_multi_hashvalue(uint32_t limit)
{
MEM_POOL* mem_pool = mem_pool_init(MB_SIZE);
int32_t ret;
struct hash_index_config config;
config.row_limit = limit;
strcpy(config.work_space,"/tmp/hash_compress_test");
system("rm -rf /tmp/hash_compress_test");
mkdirs(config.work_space);
init_profile(1000,mem_pool);
struct hash_index_manager* hash_index = hash_index_init(&config,mem_pool);
uint32_t i;
struct low_data_struct* data = (struct low_data_struct*)mem_pool_malloc(mem_pool,sizeof(struct low_data_struct));
get_low_data(data,mem_pool);
for(i=0; i<config.row_limit;i++)
{ sprintf((char*)data->data,"%d",i);
ret = hash_index_insert(hash_index,data,i);
ASSERT_EQ(0,ret);
}
verify_muti_hashvalue(hash_index,mem_pool);
hash_index_release(hash_index);
}
int DocEngine::SpecialSql(struct mile_message_header* msg_head, struct data_buffer* rbuf, struct data_buffer* sbuf){
MEM_POOL_PTR mem_pool;
void* packet;
void* result;
int32_t result_code = MILE_RETURN_SUCCESS;
uint16_t msg_type = msg_head->message_type;
switch (msg_type) {
case MT_MD_EXE_GET_KVS:
mem_pool = mem_pool_init(MB_SIZE);
packet = parse_get_kvs_packet(mem_pool, rbuf);
result = GetKvs((struct get_kvs_packet*) packet, mem_pool);
if(NULL == result){
result_code = ERROR_QUERY_BY_ROWID;
}else{
gen_query_result_packet((ResultSet*) result, msg_head,
sbuf);
}
mem_pool_destroy(mem_pool);
break;
default:
log_error("unsupported command, packet type %d", msg_type);
result_code = ERROR_UNSUPPORTED_SQL_TYPE;
break;
}
return result_code;
}
int32_t process_test_message(struct mile_message_header* msg_head,
struct data_buffer* rbuf, struct data_buffer* sbuf) {
int32_t result_code = MILE_RETURN_SUCCESS;
MEM_POOL_PTR mem_pool;
switch (msg_head->message_type) {
case MT_TEST_REQ_ECHO: // echo message for testing.
{
mem_pool = mem_pool_init(MB_SIZE);
const char *str = read_cstring(rbuf, mem_pool);
log_debug("get echo message [%s]", str);
write_int32(0, sbuf);
write_int8(msg_head->version_major, sbuf);
write_int8(msg_head->version_minor, sbuf);
write_int16(MT_TEST_RES_ECHO, sbuf);
write_int32(msg_head->message_id, sbuf);
write_int32(strlen(str), sbuf);
write_bytes((uint8_t *) str, strlen(str), sbuf);
fill_int32(sbuf->data_len, sbuf, 0);
result_code = MILE_RETURN_SUCCESS;
mem_pool_destroy(mem_pool);
}
break;
default:
result_code = -1;
break;
}
return result_code;
}
int32_t process_master_message(struct mile_message_header* msg_head,
struct data_buffer* rbuf, struct data_buffer* sbuf, void **bl_reader,
MEM_POOL_PTR session_mem) {
int32_t result_code = MILE_RETURN_SUCCESS;
MEM_POOL_PTR mem_pool;
void* packet;
struct slave_sync_res *binlog_res;
switch (msg_head->message_type) {
case MT_SM_GET_BINLOG:
mem_pool = mem_pool_init(MB_SIZE);
// STATIC_ASSERT( MB_SIZE > sizeof(struct slave_sync_res) + MAX_BINLOG_DATA_PER_PACKET, MAX_BINLOG_PACKAGE_SHOULD_LESS_THAN_MEM_POOL_SIZE);
packet = parse_slave_sync_req(mem_pool, rbuf);
binlog_res = execute_slave_sync(mem_pool,
(struct slave_sync_req *) packet, bl_reader, session_mem);
assert(NULL != binlog_res);
gen_slave_sync_res_packet(binlog_res, msg_head, sbuf);
result_code = 0;
mem_pool_destroy(mem_pool);
break;
default:
result_code = -1;
break;
}
return result_code;
}
TEST(DYHASH_CHECKPOINT2, dyhashindex){
MEM_POOL* mem_pool = mem_pool_init(MB_SIZE);
struct dyhash_index_config config;
char dir_path[] = "/tmp/dyhash_index3";
config.is_full = 0;
config.row_limit = 2;
config.is_full = 1;
strcpy(config.work_space, dir_path);
init_profile(1000,mem_pool);
struct dyhash_index_manager* dyhash_index = dyhash_index_init(&config,mem_pool);
struct low_data_struct data;
data.data = mem_pool_malloc(mem_pool, strlen("hello world"));
memset(data.data, 0, strlen("hello world"));
strcpy((char*)data.data, "hello world");
data.len = strlen("hello world");
data.type = HI_TYPE_STRING;
uint32_t count = dyhash_index_count_query(dyhash_index, &data, mem_pool);
ASSERT_EQ(1, count);
struct rowid_list* query_ret = dyhash_index_query(dyhash_index, &data, mem_pool);
print_rowid_list(query_ret);
}
int main(int argc, char* argv[])
{
char* cmd = NULL;
MEM_POOL* mem_pool = mem_pool_init(MB_SIZE);
int socket_fd;
signal(SIGPIPE, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGINT, sign_handler);
signal(SIGTERM, sign_handler);
if((socket_fd = parse_cmd_line(argc, argv, mem_pool)) <= 0)
{
mem_pool_destroy(mem_pool);
return 0;
}
while (global_start) {
if ((cmd = readline("MILE>")) == NULL) {
break;
}
parse_cmd(cmd,socket_fd,mem_pool);
mem_pool_reset(mem_pool);
if(cmd != NULL)
{
free(cmd);
cmd = NULL;
}
}
mem_pool_destroy(mem_pool);
return 0;
}
/*
* Clears the cache.
*/
static void fscache_clear(struct fscache *cache)
{
mem_pool_discard(cache->mem_pool, 0);
cache->mem_pool = NULL;
mem_pool_init(&cache->mem_pool, 0);
hashmap_free(&cache->map, 0);
hashmap_init(&cache->map, (hashmap_cmp_fn)fsentry_cmp, NULL, 0);
cache->lstat_requests = cache->opendir_requests = 0;
cache->fscache_misses = cache->fscache_requests = 0;
}
struct dyhash_index_manager* init(struct dyhash_index_config* config,char * dir_path){
char cmd[1024];
memset(cmd, 0, sizeof(cmd));
sprintf(cmd, "rm -rf %s", dir_path);
system(cmd);
mkdirs(dir_path);
MEM_POOL* mem_pool = mem_pool_init(MB_SIZE);
init_profile(1000,mem_pool);
return dyhash_index_init(config,mem_pool);
}
/*
* Enables the cache. Note that the cache is read-only, changes to
* the working directory are NOT reflected in the cache while enabled.
*/
int fscache_enable(size_t initial_size)
{
int fscache;
struct fscache *cache;
int result = 0;
/* allow the cache to be disabled entirely */
fscache = git_env_bool("GIT_TEST_FSCACHE", -1);
if (fscache != -1)
core_fscache = fscache;
if (!core_fscache)
return 0;
/*
* refcount the global fscache initialization so that the
* opendir and lstat function pointers are redirected if
* any threads are using the fscache.
*/
EnterCriticalSection(&fscache_cs);
if (!initialized) {
if (!dwTlsIndex) {
dwTlsIndex = TlsAlloc();
if (dwTlsIndex == TLS_OUT_OF_INDEXES)
return 0;
}
/* redirect opendir and lstat to the fscache implementations */
opendir = fscache_opendir;
lstat = fscache_lstat;
}
initialized++;
LeaveCriticalSection(&fscache_cs);
/* refcount the thread specific initialization */
cache = fscache_getcache();
if (cache) {
cache->enabled++;
} else {
cache = (struct fscache *)xcalloc(1, sizeof(*cache));
cache->enabled = 1;
/*
* avoid having to rehash by leaving room for the parent dirs.
* '4' was determined empirically by testing several repos
*/
hashmap_init(&cache->map, (hashmap_cmp_fn)fsentry_cmp, NULL, initial_size * 4);
mem_pool_init(&cache->mem_pool, 0);
if (!TlsSetValue(dwTlsIndex, cache))
BUG("TlsSetValue error");
}
trace_printf_key(&trace_fscache, "fscache: enable\n");
return result;
}
void test_tow_hashvalue(uint32_t limit)
{
MEM_POOL* mem_pool = mem_pool_init(MB_SIZE);
struct hash_index_config config;
config.row_limit = limit;
strcpy(config.work_space,"/tmp/hash_compress_test");
system("rm -rf /tmp/hash_compress_test");
mkdirs(config.work_space);
init_profile(1000,mem_pool);
struct hash_index_manager* hash_index = hash_index_init(&config,mem_pool);
uint32_t i;
struct low_data_struct* data = (struct low_data_struct*)mem_pool_malloc(mem_pool,sizeof(struct low_data_struct));
get_low_data(data,mem_pool);
for(i=0; i<config.row_limit/2;i++)
{
strcpy((char*)data->data,"1");
hash_index_insert(hash_index,data,i);
}
for(i=config.row_limit/2; i<config.row_limit;i++)
{
strcpy((char*)data->data,"2");
hash_index_insert(hash_index,data,i);
}
struct hash_compress_manager* hash_compress = hash_compress_load(hash_index,10,mem_pool);
struct rowid_list* rlist_a;
struct rowid_list* rlist_b;
get_low_data(data,mem_pool);
strcpy((char*)data->data,"1");
rlist_a = hash_index_query(hash_index,data,mem_pool);
rlist_b = hash_compress_query(hash_compress,data,mem_pool);
ASSERT_EQ(rowid_list_equals(rlist_a,rlist_b),1);
strcpy((char*)data->data,"2");
rlist_a = hash_index_query(hash_index,data,mem_pool);
rlist_b = hash_compress_query(hash_compress,data,mem_pool);
ASSERT_EQ(rowid_list_equals(rlist_a,rlist_b),1);
hash_index_release(hash_index);
hash_compress_release(hash_compress);
}
TEST(DYHASH_RECOVER2, dyhashindex){
MEM_POOL* mem_pool = mem_pool_init(MB_SIZE);
struct dyhash_index_config config;
char dir_path[] = "/tmp/dyhash_index4";
config.is_full = 1;
config.row_limit = 8;
strcpy(config.work_space, dir_path);
struct low_data_struct data;
data.data = malloc(strlen("hello1world") + 1);
memset(data.data, 0, strlen("hello1world") + 1);
data.len = strlen("hello1world");
data.type = HI_TYPE_STRING;
struct dyhash_index_manager* dyhash_index = dyhash_index_init(&config, mem_pool);
int32_t ret;
dyhash_index_recover(dyhash_index, 3);
strcpy((char*)data.data, "hello1world");
uint32_t count = dyhash_index_count_query(dyhash_index, &data, mem_pool);
ASSERT_EQ(3, count);
strcpy((char*)data.data, "hello2world");
count = dyhash_index_count_query(dyhash_index, &data, mem_pool);
ASSERT_EQ(0, count);
strcpy((char*)data.data, "hello1world");
ret = dyhash_index_insert(dyhash_index,&data,3);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello2world");
ret = dyhash_index_insert(dyhash_index,&data,4);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello2world");
ret = dyhash_index_insert(dyhash_index,&data,5);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello1world");
count = dyhash_index_count_query(dyhash_index, &data, mem_pool);
ASSERT_EQ(4, count);
strcpy((char*)data.data, "hello2world");
count = dyhash_index_count_query(dyhash_index, &data, mem_pool);
ASSERT_EQ(2, count);
}
TEST(DYHASH_RECOVER1, dyhashindex){
MEM_POOL* mem_pool = mem_pool_init(MB_SIZE);
struct dyhash_index_config config;
char dir_path[] = "/tmp/dyhash_index4";
config.is_full = 0;
config.row_limit = 8;
strcpy(config.work_space, dir_path);
struct dyhash_index_manager* dyhash_index = init(&config,dir_path);
struct low_data_struct data;
data.data = mem_pool_malloc(mem_pool, strlen("hello1world"));
memset(data.data, 0, strlen("hello1world"));
data.len = strlen("hello world");
data.type = HI_TYPE_STRING;
int32_t ret = 0;
strcpy((char*)data.data, "hello1world");
ret = dyhash_index_insert(dyhash_index,&data,0);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello1world");
ret = dyhash_index_insert(dyhash_index,&data,1);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello1world");
ret = dyhash_index_insert(dyhash_index,&data,2);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello1world");
ret = dyhash_index_insert(dyhash_index,&data,3);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello2world");
ret = dyhash_index_insert(dyhash_index,&data,4);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello2world");
ret = dyhash_index_insert(dyhash_index,&data,5);
ASSERT_EQ(0, ret);
dyhash_index_release(dyhash_index);
}
/**
* @brief Initialize the target hardware and the console
* @param None
* @retval None
*/
void MOD_PreInit(void)
{
memset(MOD_table, 0, sizeof(GROUP_InitTypeDef));
/* Init Console to save events log*/
CONSOLE_Init();
CONSOLE_LOG((uint8_t *)"[SYSTEM] Module Manager running....");
/* Init Board specific hardware */
BSP_Init();
/*Init heap memory (located in SRAM)*/
mem_pool_init();
}
TEST(STORE_STAT_TEST, HandleNoneZeroInput)
{
MEM_POOL* mem_pool = mem_pool_init(M_1M);
store_stats_init(1000*10,mem_pool);
uint64 i;
for(i=0;i<10000;i++)
record_time("index_equal",1000*100);
ASSERT_EQ(100.000000,get_avg_time_inms("index_equal"));
ASSERT_EQ(10000,get_count("index_equal"));
ASSERT_EQ(10000,get_total_count("index_equal"));
sleep(2);
ASSERT_EQ(5000,get_throughput("index_equal"));
}
/**
* Long path for mem_pools_alloc
*
* @return true - if there is a free chunk in mem_pools,
* false - otherwise (not enough memory).
*/
static bool __attr_noinline___
mem_pools_alloc_longpath (void)
{
/**
* If there are no free chunks, allocate new pool.
*/
if (mem_free_chunks_number == 0)
{
mem_pool_state_t *pool_state = (mem_pool_state_t*) mem_heap_alloc_block (MEM_POOL_SIZE, MEM_HEAP_ALLOC_LONG_TERM);
JERRY_ASSERT (pool_state != NULL);
mem_pool_init (pool_state, MEM_POOL_SIZE);
MEM_CP_SET_POINTER (pool_state->next_pool_cp, mem_pools);
mem_pools = pool_state;
mem_free_chunks_number += MEM_POOL_CHUNKS_NUMBER;
MEM_POOLS_STAT_ALLOC_POOL ();
}
else
{
/**
* There is definitely at least one pool of specified type with at least one free chunk.
*
* Search for the pool.
*/
mem_pool_state_t *pool_state = mem_pools, *prev_pool_state_p = NULL;
while (pool_state->first_free_chunk == MEM_POOL_CHUNKS_NUMBER)
{
prev_pool_state_p = pool_state;
pool_state = MEM_CP_GET_NON_NULL_POINTER (mem_pool_state_t, pool_state->next_pool_cp);
}
JERRY_ASSERT (prev_pool_state_p != NULL && pool_state != mem_pools);
prev_pool_state_p->next_pool_cp = pool_state->next_pool_cp;
MEM_CP_SET_NON_NULL_POINTER (pool_state->next_pool_cp, mem_pools);
mem_pools = pool_state;
}
return true;
} /* mem_pools_alloc_longpath */
void* MainStep::Execute(TableManager* table, void* input, int32_t &result_code,
int64_t timeout, MEM_POOL_PTR mem_pool) {
MileIterator* iter = (MileIterator*) input;
MileIterator* step_iter = substeps->CreateIterator();
uint32_t i = 0;
uint32_t cut_threshold=table->getCutThreshold();
ExecuteSubstep* substep;
MEM_POOL_PTR inner_mem_pool = mem_pool_init(MB_SIZE);
for (iter->First(); !iter->IsDone(); iter->Next()) {
for (step_iter->First(); !step_iter->IsDone(); step_iter->Next()) {
substep = (ExecuteSubstep*) step_iter->CurrentItem();
result_code = substep->Execute(table,
(MileHandler*) iter->CurrentItem(), result, inner_mem_pool);
if (result_code != 0) {
break;
}
}
mem_pool_reset(inner_mem_pool);
if (result_code < 0) {
break;
}
if((++i) % 100 == 0){
if(get_time_msec() > timeout){
result_code = ERROR_TIMEOUT;
break;
}
}
if( cut_threshold > 0 && i >= cut_threshold )
{
break;
}
}
mem_pool_destroy(inner_mem_pool);
if (result_code == WARN_EXCEED_QUERY_LIMIT || result_code >= 0) {
result_code = MILE_RETURN_SUCCESS;
}
return result;
}
TEST(DATA_BUFFER_TEST, READ_AND_WRITE){
MEM_POOL_PTR pMemPool = mem_pool_init(MB_SIZE);
struct data_buffer* buffer = init_data_buffer();
buffer->data_len = 256;
buffer->data = (uint8*) mem_pool_malloc(pMemPool, 256);
uint8 tmp8;
uint16 tmp16;
uint32 tmp32;
uint64 tmp64;
char* str = (char*) mem_pool_malloc(pMemPool, 100);
char* result = (char*) mem_pool_malloc(pMemPool, 100);
strcpy(str, "hello world!");
write_int8(122, buffer);
write_int16(1111, buffer);
write_int32(324, buffer);
write_int64(2321, buffer);
write_bytes((uint8*)str, strlen(str)+1, buffer);
tmp8 = read_int8(buffer);
ASSERT_EQ(tmp8, 122);
tmp16 = read_int16(buffer);
ASSERT_EQ(tmp16, 1111);
tmp32 = read_int32(buffer);
ASSERT_EQ(tmp32, 324);
tmp64 = read_int64(buffer);
ASSERT_EQ(tmp64, 2321);
read_bytes(buffer, (uint8*)result, strlen(str)+1);
ASSERT_EQ(0, strcmp(str, result));
destroy_data_buffer(buffer);
mem_pool_destroy(pMemPool);
}
TEST(DYHASH_CHECKPOINT1, dyhashindex){
MEM_POOL* mem_pool = mem_pool_init(MB_SIZE);
struct dyhash_index_config config;
char dir_path[] = "/tmp/dyhash_index3";
config.is_full = 0;
config.row_limit = 2;
strcpy(config.work_space, dir_path);
struct dyhash_index_manager* dyhash_index = init(&config,dir_path);
int32_t ret = 0;
uint32_t docid = 0;
struct low_data_struct data;
data.data = mem_pool_malloc(mem_pool, strlen("hello world"));
memset(data.data, 0, strlen("hello world"));
strcpy((char*)data.data, "hello world");
data.len = strlen("hello world");
data.type = HI_TYPE_STRING;
uint32_t i;
for(i=0; i<10; i++)
{
ret = dyhash_index_insert(dyhash_index,&data,docid);
ASSERT_EQ(0, ret);
}
dyhash_index_checkpoint(dyhash_index);
struct rowid_list* query_ret = dyhash_index_query(dyhash_index, &data, mem_pool);
print_rowid_list(query_ret);
}
virtual void SetUp()
{
ClearDir();
::mkdir(dir_.c_str(), 0755);
mem_ = mem_pool_init( 1 << 20); // MB
// init config
ConfigFile &conf = *ConfigFile::GlobalInstance();
conf.SetValue(CONF_LDB_SESSION, CONF_LDB_TABLES, "t");
// use user specified time
conf.SetValue(CONF_LDB_SESSION, "t.row_key", "k");
conf.SetValue(CONF_LDB_SESSION, "t.time_key", "t");
conf.SetValue(CONF_LDB_SESSION, "t.time_key_scale", "0");
conf.SetValue(CONF_LDB_SESSION, "t.time_key_len", "4");
conf.SetValue(CONF_LDB_SESSION, "t.cumulative_step", "10,100,200");
conf.SetValue(CONF_LDB_SESSION, "t.aggregate_desc", "count(*),max(value),min(value),sum(value)");
conf.SetValue(CONF_LDB_SESSION, "max_open_files", "512");
engine_ = NEW(mem_, LdbEngine)(dir_.c_str(), conf);
ASSERT_EQ(0, engine_->Init());
}
TEST(BITMARK_TEST, HandleNoneZeroInput) {
int32 ret;
int32 value;
MEM_POOL* mem_pool = mem_pool_init(M_1M);
struct bitmark_config config;
strcpy(config.bitmark_name,"null");
strcpy(config.work_space,"/tmp/bitmark_test");
config.row_limit = 10;
system("rm -rf /tmp/bitmark_test");
init_profile(1000,mem_pool);
mkdirs(config.work_space);
struct bitmark_manager* bitmark = bitmark_init(&config, mem_pool);
//全部置零
bitmark_reset(bitmark);
//置位
//表示6行已插入该行值
ret = bitmark_set(bitmark,6);
ASSERT_EQ(ret,0);
//查询
value = bitmark_query(bitmark,6);
ASSERT_EQ(value,0);
value = bitmark_query(bitmark,8);
ASSERT_EQ(value,1);
//删除6行的值
ret = bitmark_clear(bitmark,6);
ASSERT_EQ(ret,0);
mem_pool_destroy(mem_pool);
}
int DocEngine::Command(struct mile_message_header* msg_head,
struct data_buffer* rbuf, struct data_buffer* sbuf) {
MEM_POOL_PTR mem_pool;
void* parsed_packet;
void* result;
int32_t result_code = 0;
uint16_t msg_type = msg_head->message_type;
switch (msg_type) {
case MT_MD_EXE_GET_KVS:
mem_pool = mem_pool_init(MB_SIZE);
parsed_packet = parse_get_kvs_packet(mem_pool, rbuf);
result = GetKvs((struct get_kvs_packet*) parsed_packet, mem_pool);
if(NULL == result){
result_code = ERROR_QUERY_BY_ROWID;
}else{
gen_query_result_packet((ResultSet*) result, msg_head,
sbuf);
}
mem_pool_destroy(mem_pool);
break;
case MT_CD_EXE_COMPRESS:
mem_pool = mem_pool_init(KB_SIZE);
parsed_packet = parse_compress_packet(mem_pool, rbuf);
log_debug(
"接收到compress命令:%s", ((struct compress_packet*)parsed_packet)->table_name);
db_read_lock();
result_code = db_compress(
((struct compress_packet*) parsed_packet)->table_name,
mem_pool);
db_read_unlock();
gen_dc_response_packet(result_code, msg_head, sbuf);
mem_pool_destroy(mem_pool);
break;
case MT_CD_EXE_INDEX:
mem_pool = mem_pool_init(KB_SIZE);
parsed_packet = parse_ensure_index_packet(mem_pool, rbuf);
log_debug(
"接收到ensure_index命令 %s %s %u %u", ((struct ensure_index_packet*)parsed_packet)->table_name, ((struct ensure_index_packet*)parsed_packet)->field_name, ((struct ensure_index_packet*)parsed_packet)->index_type, ((struct ensure_index_packet*)parsed_packet)->data_type);
db_read_lock();
result_code = db_ensure_index(
((struct ensure_index_packet*) parsed_packet)->table_name,
((struct ensure_index_packet*) parsed_packet)->field_name,
((struct ensure_index_packet*) parsed_packet)->index_type,
((struct ensure_index_packet*) parsed_packet)->data_type,
mem_pool);
db_read_unlock();
gen_dc_response_packet(result_code, msg_head, sbuf);
mem_pool_destroy(mem_pool);
break;
case MT_CD_EXE_UNINDEX:
mem_pool = mem_pool_init(KB_SIZE);
parsed_packet = parse_del_index_packet(mem_pool, rbuf);
log_debug(
"接收到del_index命令 %s %s %u", ((struct del_index_packet*)parsed_packet)->table_name, ((struct del_index_packet*)parsed_packet)->field_name, ((struct del_index_packet*)parsed_packet)->index_type);
db_read_lock();
result_code = db_del_index(
((struct del_index_packet*) parsed_packet)->table_name,
((struct del_index_packet*) parsed_packet)->field_name,
((struct del_index_packet*) parsed_packet)->index_type,
mem_pool);
db_read_unlock();
gen_dc_response_packet(result_code, msg_head, sbuf);
mem_pool_destroy(mem_pool);
break;
case MT_CD_EXE_LOAD:
mem_pool = mem_pool_init(KB_SIZE);
parsed_packet = parse_load_segment_packet(mem_pool, rbuf);
log_debug(
"接收到load_segment命令 %s %u %s", ((struct load_segment_packet*)parsed_packet)->table_name, ((struct load_segment_packet*)parsed_packet)->sid, ((struct load_segment_packet*)parsed_packet)->segment_dir);
db_read_lock();
result_code = db_load_segment(
((struct load_segment_packet*) parsed_packet)->table_name,
((struct load_segment_packet*) parsed_packet)->sid,
((struct load_segment_packet*) parsed_packet)->segment_dir,
mem_pool);
db_read_unlock();
gen_dc_response_packet(result_code, msg_head, sbuf);
mem_pool_destroy(mem_pool);
break;
case MT_CD_EXE_REPLACE:
mem_pool = mem_pool_init(KB_SIZE);
parsed_packet = parse_replace_segment_packet(mem_pool, rbuf);
log_debug(
"接收到replace segments命令 %s %s", ((struct replace_segment_packet*)parsed_packet)->table_name, ((struct replace_segment_packet*)parsed_packet)->segment_dir);
db_read_lock();
result_code = db_replace_all_segments(
((struct replace_segment_packet*) parsed_packet)->table_name,
((struct replace_segment_packet*) parsed_packet)->segment_dir,
mem_pool);
db_read_unlock();
gen_dc_response_packet(result_code, msg_head, sbuf);
mem_pool_destroy(mem_pool);
break;
case MT_CD_EXE_UNLOAD:
mem_pool = mem_pool_init(KB_SIZE);
parsed_packet = parse_unload_segment_packet(mem_pool, rbuf);
log_debug(
"接收到unload_segment命令 %s %u", ((struct unload_segment_packet*)parsed_packet)->table_name, ((struct unload_segment_packet*)parsed_packet)->sid);
db_read_lock();
result_code = db_unload_segment(
((struct unload_segment_packet*) parsed_packet)->table_name,
((struct unload_segment_packet*) parsed_packet)->sid, mem_pool);
db_read_unlock();
gen_dc_response_packet(result_code, msg_head, sbuf);
mem_pool_destroy(mem_pool);
break;
case MT_CD_EXE_CP:
log_debug( "get checkpoint command");
db_checkpoint();
gen_dc_response_packet(0, msg_head, sbuf);
break;
case MT_CD_STAT:
mem_pool = mem_pool_init(MB_SIZE);
parsed_packet = parse_doc_stat_packet(mem_pool, rbuf);
log_debug(
"接收到stat命令 %s %u", ((struct doc_stat_packet*)parsed_packet)->table_name, ((struct doc_stat_packet*)parsed_packet)->type);
if (((struct doc_stat_packet*) parsed_packet)->type == 1) {
uint16_t max_segment_num = 0;
struct segment_meta_data* result = NULL;
db_read_lock();
result = db_query_segment_stat(
((struct doc_stat_packet*) parsed_packet)->table_name,
&max_segment_num, mem_pool);
db_read_unlock();
gen_dc_segment_stat_packet(result, max_segment_num, msg_head, sbuf);
}
if (((struct doc_stat_packet*) parsed_packet)->type == 2) {
uint16_t index_field_count = 0;
struct index_field_meta* result = NULL;
db_read_lock();
result = db_query_index_stat(
((struct doc_stat_packet*) parsed_packet)->table_name,
&index_field_count, mem_pool);
db_read_unlock();
gen_dc_index_stat_packet(result, index_field_count, msg_head, sbuf);
}
mem_pool_destroy(mem_pool);
break;
default:
log_error("unsupported command, packet type %d", msg_type);
result_code = ERROR_UNSUPPORTED_SQL_TYPE;
break;
}
return result_code;
}
TEST(BTREETEST, HandleNoneZeroInput) {
MEM_POOL_PTR pMemPool = mem_pool_init(M_1M);
BTREE_PTR pBtree = btree_init(pMemPool, "zbtree_index", "/tmp/", 3*MAX, HI_TYPE_LONGLONG);
// BTREE_PTR pBtree = btree_init(pMemPool, "zbtree_index", "/tmp/", 3*MAX, HI_TYPE_LONG);
BTREE_PTR pBtree2 = btree_init(pMemPool, "zbtree_index2", "/tmp/", 3*MAX, HI_TYPE_DOUBLE);
init_profile(1000, pMemPool);
/*
struct timeval start, end, end2;
double interval;
gettimeofday(&start, NULL);
srand((unsigned int)time(NULL));
int res,i;
uint64 num;
//插入10万数据
for ( i = 0; i < MAX; i += 1 )
{
num = rand()%MAX;
res = btree_insert(pMemPool, pBtree, num, i);
ASSERT_EQ(res, 0);
}
gettimeofday(&end, NULL);
interval = 1000000*(end.tv_sec - start.tv_sec) + (end.tv_usec - start.tv_usec);
printf("insert %d data, cost %.2f ms\n", MAX, interval /1000);
//范围查询10万次
BTREE_ENTRY_PTR pBtreeEntry;
uint32 num2;
// struct rowid_list *pRowidList;
for ( i = 0; i < MAX; i += 1 )
{
num = rand()%MAX+100;
pBtreeEntry = btree_search(pBtree, num, CT_LE);
// num2 = rand()%MAX+100;
// struct rowid_list * pRowidList = btree_range_query(pBtree, num, 0, num2, 0, pMemPool);
// if(pRowidList!=NULL)
// {
// printf("%d:", i);
// print_rowid_list(pRowidList);
// }
// ASSERT_EQ((pBtreeEntry != NULL), 1);
}
gettimeofday(&end2, NULL);
interval = 1000000*(end2.tv_sec - end.tv_sec) + (end2.tv_usec - end.tv_usec);
printf("search %d data, cost %.2f ms\n", MAX, interval /1000);
*/
//插入3 7 7 9 11 2 4 5 6 8
int res = btree_insert(pMemPool, pBtree, 3, 1);
ASSERT_EQ(res, 0);
res = btree_insert(pMemPool, pBtree, 7, 2);
ASSERT_EQ(res, 0);
res = btree_insert(pMemPool, pBtree, 7, 10);
ASSERT_EQ(res, 0);
res = btree_insert(pMemPool, pBtree, 9, 3);
ASSERT_EQ(res, 0);
res = btree_insert(pMemPool, pBtree, 11, 4);
ASSERT_EQ(res, 0);
res = btree_insert(pMemPool, pBtree, 2, 5);
ASSERT_EQ(res, 0);
res = btree_insert(pMemPool, pBtree, 4, 6);
ASSERT_EQ(res, 0);
res = btree_insert(pMemPool, pBtree, 5, 7);
ASSERT_EQ(res, 0);
res = btree_insert(pMemPool, pBtree, 6, 8);
ASSERT_EQ(res, 0);
res = btree_insert(pMemPool, pBtree, 8, 9);
ASSERT_EQ(res, 0);
//等值查找3 9 8
// long long value = 3;
BTREE_ENTRY_PTR pBtreeEntry = btree_search(pBtree, 3, CT_EQ);
ASSERT_EQ((pBtreeEntry != NULL), 1);
ASSERT_EQ(pBtreeEntry->key, 3);
pBtreeEntry = btree_search(pBtree, 9, CT_EQ);
ASSERT_EQ((pBtreeEntry != NULL), 1);
ASSERT_EQ(pBtreeEntry->key, 9);
pBtreeEntry = btree_search(pBtree, 1, CT_EQ);
ASSERT_EQ((pBtreeEntry == NULL), 1);
//查找<7 <6
pBtreeEntry = btree_search(pBtree, 7, CT_LT);
ASSERT_EQ((pBtreeEntry != NULL), 1);
ASSERT_EQ(pBtreeEntry->key, 6);
pBtreeEntry = btree_search(pBtree, 6, CT_LT);
ASSERT_EQ((pBtreeEntry != NULL), 1);
ASSERT_EQ(pBtreeEntry->key, 5);
//查找>7 >6
pBtreeEntry = btree_search(pBtree, 7, CT_GT);
ASSERT_EQ((pBtreeEntry != NULL), 1);
ASSERT_EQ(pBtreeEntry->key, 8);
pBtreeEntry = btree_search(pBtree, 6, CT_GT);
ASSERT_EQ((pBtreeEntry != NULL), 1);
ASSERT_EQ(pBtreeEntry->key, 7);
//测试btree next
//BTREE_ENTRY_PTR pEntry = btree_search(pBtree, 2, 0);
BTREE_ENTRY_PTR pEntry = btree_get_start_entry(pBtree);
struct doc_row_unit *pUnit;
while(pEntry != NULL)
{
std::cout << "key = " << pEntry->key << " docID: ";
//输出doclist
pUnit = doclist_next(pBtree->pDoclist, pEntry->doclist);
while(pUnit != NULL)
{
std::cout << pUnit->doc_id << " ";
pUnit = doclist_next(pBtree->pDoclist, pUnit->next);
}
pEntry = btree_next(pBtree, pEntry);
std::cout << std::endl;
}
std::cout << std::endl;
struct rowid_list * pRowidList = btree_range_query(pBtree, 0, 0, 10, 0, pMemPool);
print_rowid_list(pRowidList);
BTREE_KEY key;
double value;
//insert 3.1 11.11 111.111 1111.1 11111.1 11.11
value =3.1;
memcpy(&key, &value, 8);
res = btree_insert(pMemPool, pBtree2, key, 1);
ASSERT_EQ(res, 0);
value =11.11;
memcpy(&key, &value, 8);
res = btree_insert(pMemPool, pBtree2, key, 2);
ASSERT_EQ(res, 0);
value =111.111;
memcpy(&key, &value, 8);
res = btree_insert(pMemPool, pBtree2, key, 3);
ASSERT_EQ(res, 0);
value =1111.1;
memcpy(&key, &value, 8);
res = btree_insert(pMemPool, pBtree2, key, 4);
ASSERT_EQ(res, 0);
value =11111.1;
memcpy(&key, &value, 8);
res = btree_insert(pMemPool, pBtree2, key, 5);
ASSERT_EQ(res, 0);
value =11.11;
memcpy(&key, &value, 8);
res = btree_insert(pMemPool, pBtree2, key, 6);
ASSERT_EQ(res, 0);
value =1111;
memcpy(&key, &value, 8);
pRowidList = btree_range_query(pBtree2, 0, 0, key, 0, pMemPool);
print_rowid_list(pRowidList);
pEntry = btree_get_start_entry(pBtree2);
while(pEntry != NULL)
{
std::cout << "key = " << *(double*)&pEntry->key << " docID: ";
//输出doclist
pUnit = doclist_next(pBtree2->pDoclist, pEntry->doclist);
while(pUnit != NULL)
{
std::cout << pUnit->doc_id << " ";
pUnit = doclist_next(pBtree2->pDoclist, pUnit->next);
}
pEntry = btree_next(pBtree2, pEntry);
std::cout << std::endl;
}
std::cout << std::endl;
//测试dump
//btree_dump(pBtree);
btree_destroy(pBtree);
btree_destroy(pBtree2);
}
DocEngine::DocEngine(const char *storage_dir, const ConfigFile &conf) :
storage_dir_(storage_dir), conf_(&conf), db_conf_(NULL) {
mem_ = mem_pool_init(1 << 20);
}
int32_t process_mergeserver_message(struct mile_message_header* msg_head,
struct data_buffer* rbuf, struct data_buffer* sbuf,
int16_t exceed_cpu_used, uint64_t deadline_time) {
int32_t result_code = MILE_RETURN_SUCCESS;
MEM_POOL_PTR mem_pool;
void* parsed_packet;
ExecutePlan* plan = NULL;
void* result;
switch (msg_head->message_type) {
case MT_MD_EXE_INSERT:
mem_pool = mem_pool_init(MB_SIZE);
parsed_packet = parse_insert_packet(mem_pool, rbuf);
plan = SqlAnalyzer::Analyze(StorageEngine::storage,
(struct insert_packet*) parsed_packet, mem_pool);
if (plan == NULL) {
result_code = -1;
} else {
result = plan->Execute(result_code, deadline_time);
plan->~ExecutePlan();
}
if (result_code == MILE_RETURN_SUCCESS) {
gen_insert_result_packet(*(uint64_t*) result, msg_head, sbuf);
}
mem_pool_destroy(mem_pool);
break;
case MT_MD_EXE_DELETE:
if (exceed_cpu_used) {
log_warn("cpu使用率超出，拒绝UPDATE QUERY DELETE服务");
break;
}
mem_pool = mem_pool_init(MB_SIZE);
parsed_packet = parse_delete_packet(mem_pool, rbuf);
plan = SqlAnalyzer::Analyze(StorageEngine::storage,
(struct delete_packet*) parsed_packet, mem_pool);
if (plan == NULL) {
result_code = -1;
} else {
result = plan->Execute(result_code, deadline_time);
plan->~ExecutePlan();
}
if (result_code == MILE_RETURN_SUCCESS) {
gen_delete_result_packet(*(uint32_t*) result, msg_head, sbuf);
}
mem_pool_destroy(mem_pool);
break;
case MT_MD_EXE_EXPORT: {
mem_pool = mem_pool_init(MB_SIZE);
parsed_packet = parse_export_packet(mem_pool, rbuf);
plan = SqlAnalyzer::Analyze(StorageEngine::storage,
(struct export_packet *) parsed_packet, mem_pool);
if (plan == NULL) {
result_code = -1;
} else {
result = plan->Execute(result_code, deadline_time);
plan->~ExecutePlan();
}
if (result_code == MILE_RETURN_SUCCESS) {
gen_export_result_packet(*(uint64_t*) result, msg_head, sbuf);
}
mem_pool_destroy(mem_pool);
}
break;
case MT_MD_EXE_UPDATE:
if (exceed_cpu_used) {
log_warn("cpu使用率超出，拒绝UPDATE QUERY DELETE服务");
break;
}
mem_pool = mem_pool_init(MB_SIZE);
parsed_packet = parse_update_packet(mem_pool, rbuf);
plan = SqlAnalyzer::Analyze(StorageEngine::storage,
(struct update_packet*) parsed_packet, mem_pool);
if (plan == NULL) {
result_code = -1;
} else {
result = plan->Execute(result_code, deadline_time);
plan->~ExecutePlan();
}
if (result_code == MILE_RETURN_SUCCESS) {
gen_update_result_packet(*(uint32_t*) result, msg_head, sbuf);
}
mem_pool_destroy(mem_pool);
break;
case MT_MD_EXE_QUERY:
if (exceed_cpu_used) {
log_warn("cpu使用率超出，拒绝UPDATE QUERY DELETE服务");
break;
}
mem_pool = mem_pool_init(MB_SIZE);
result_code = loadavg_check(); // check overloading
if (ERROR_OS_OVERLOADING == result_code) {
log_warn(
"OS overloading, discard packet msg id %"PRIu32, msg_head->message_id);
} else if (0 == result_code) {
parsed_packet = parse_query_packet(mem_pool, rbuf);
plan = SqlAnalyzer::Analyze(StorageEngine::storage,
(struct query_packet*) parsed_packet, mem_pool);
if (plan == NULL) {
result_code = -1;
} else {
result = plan->Execute(result_code, deadline_time);
plan->~ExecutePlan();
}
}
if (result_code == MILE_RETURN_SUCCESS) {
gen_query_result_packet((ResultSet*) result, msg_head, sbuf);
}
mem_pool_destroy(mem_pool);
break;
case MT_MD_GET_STATE:
mem_pool = mem_pool_init(KB_SIZE);
parsed_packet = parse_get_state_packet(mem_pool, rbuf);
result = StateManager::QueryStates(StorageEngine::storage,
(struct get_state_packet*) parsed_packet, mem_pool);
if (result == NULL) {
result_code = ERROR_GET_DOCSERVER_STATE;
} else {
gen_state_result_packet((struct stat_info_array*) result, msg_head,
sbuf);
}
mem_pool_destroy(mem_pool);
break;
default:
result_code = StorageEngine::storage->SpecialSql(msg_head, rbuf, sbuf);
break;
}
if (result_code < 0) {
gen_error_packet(result_code, msg_head, sbuf);
}
return result_code;
}
TEST(HASHINDEX_TEST, HandleNoneZeroInput) {
MEM_POOL* mem_pool = mem_pool_init(MB_SIZE);
struct hash_index_config config;
system("rm -rf /tmp/hashindex_test");
char dir_path[] = "/tmp/hashindex_test";
mkdirs(dir_path);
config.row_limit = BUCKET_NUM;
strcpy(config.work_space,dir_path);
init_profile(1000,mem_pool);
int32_t ret;
//插入一个值
struct low_data_struct insert_data;
get_low_data(&insert_data,mem_pool);
struct hash_index_manager* hash_index = hash_index_init(&config,mem_pool);
ret = hash_index_insert(hash_index,&insert_data,0);
ASSERT_EQ(ret,0);
//查询
struct rowid_list* rowids;
uint32_t i;
struct rowid_list_node* p;
rowids = hash_index_query(hash_index,&insert_data,mem_pool);
for(i = 0, p = rowids->head; i < rowids->rowid_num; i++)
{
if(i != 0 && i%ROWID_ARRAY_SIZE == 0)
{
p = p->next;
}
ASSERT_EQ(p->rowid_array[i%ROWID_ARRAY_SIZE],0);
break;
}
//再插入一个值
hash_index_insert(hash_index,&insert_data,1);
rowids = hash_index_query(hash_index,&insert_data,mem_pool);
for(i = 0, p = rowids->head; i < rowids->rowid_num; i++)
{
if(i != 0 && i%ROWID_ARRAY_SIZE == 0)
{
p = p->next;
if(i==0)
ASSERT_EQ(p->rowid_array[i%ROWID_ARRAY_SIZE],1);
if(i==1)
{
ASSERT_EQ(p->rowid_array[i%ROWID_ARRAY_SIZE],0);
break;
}
}
}
//插入BUCKET_NUM个
for(i=2; i<BUCKET_NUM+1; i++)
{
sprintf((char*)insert_data.data,"ali%u",i);
ret = hash_index_insert(hash_index,&insert_data,i);
ASSERT_EQ(ret,0);
}
//再插一个报冲突了
sprintf((char*)insert_data.data,"ali%u",i);
ret = hash_index_insert(hash_index,&insert_data,i);
ASSERT_EQ(ret,ERROR_HASH_CONFLICT);
//插入一个空值，OK
insert_data.len = 0;
ret = hash_index_insert(hash_index,&insert_data,i);
ASSERT_EQ(ret,0);
rowids = hash_index_query(hash_index,&insert_data,mem_pool);
ASSERT_EQ(rowids->rowid_num,1);
ASSERT_EQ(rowids->head->rowid_array[0],5);
hash_index_release(hash_index);
mem_pool_destroy(mem_pool);
}
TEST(RECOVER_TEST_2, HandleNoneZeroInput) {
MEM_POOL* mem_pool = mem_pool_init(MB_SIZE);
struct hash_index_config config;
system("rm -rf /tmp/hashindex_test");
char dir_path[] = "/tmp/hashindex_test";
mkdirs(dir_path);
config.row_limit = ROW_LIMIT;
strcpy(config.work_space,dir_path);
init_profile(1000,mem_pool);
int32_t ret;
struct hash_index_manager* hash_index = hash_index_init(&config,mem_pool);
//插入18条数据，只恢复16条
uint32_t i;
struct low_data_struct* data = (struct low_data_struct*)mem_pool_malloc(mem_pool, sizeof(struct low_data_struct));
memset(data, 0, sizeof(struct low_data_struct));
for(i=0; i<18; i++)
{
if(i != 0 && i%2 == 1)
continue;
data->len = 5;
data->data = mem_pool_malloc(mem_pool,5);
data->type = HI_TYPE_STRING;
data->field_name = (char*)mem_pool_malloc(mem_pool,20);
memset(data->field_name,0,20);
strcpy(data->field_name,"HI_TYPE_STRING");
memset(data->data,0,5);
ret = hash_index_insert(hash_index,data,i);
ASSERT_EQ(0, ret);
ret = hash_index_insert(hash_index,data,i+1);
ASSERT_EQ(0, ret);
}
struct doc_row_unit* doc = NULL;
ASSERT_EQ(0, hash_index_recover(hash_index, 16));
for(i=0; i<ROW_LIMIT; i++)
{
doc = GET_DOC_ROW_STRUCT(hash_index->doclist, i);
}
//验证
for(i=0; i<16; i++)
{
doc = GET_DOC_ROW_STRUCT(hash_index->doclist, i);
ASSERT_EQ(i, doc->doc_id);
}
for(i=16; i<ROW_LIMIT; i++)
{
doc = GET_DOC_ROW_STRUCT(hash_index->doclist, i);
ASSERT_EQ(0, doc->doc_id);
ASSERT_EQ(0,doc->next);
}
struct hash_bucket* hbucket = NULL;
uint32_t bucket_no = 0;
for(i=0; i<ROW_LIMIT+1; i++)
{
hbucket = hash_index->mem_mmaped + i;
doc = NEXT_DOC_ROW_STRUCT(hash_index->doclist, hbucket->offset);
if(hbucket->hash_value == 0)
{
continue;
}
while(!(doc->next & 0x80000000))
{
ASSERT_GT(16, doc->doc_id);
doc = NEXT_DOC_ROW_STRUCT(hash_index->doclist, doc->next);
}
bucket_no = doc->next & 0x7fffffff;
ASSERT_EQ(i,bucket_no);
}
hash_index_release(hash_index);
mem_pool_destroy(mem_pool);
}
int main()
{
mem_pool_init();
int i;
void *a;
void *b;
/*
for(i=0;i<1000;i++)
{
a=mem_alloc(5);
printf("+++++++++++++++the %d addr is %x\n",i,(unsigned int)a);
i++;
b=mem_alloc(5);
printf("+++++++++++++++the %d addr is %x\n",i,(unsigned int)b);
mem_free(a);
mem_free(b);
}
for(i=0;i<1000;i++)
{
a=mem_alloc(18);
printf("+++++++++++++++the %d addr is %x\n",i,(unsigned int)a);
i++;
b=mem_alloc(18);
printf("+++++++++++++++the %d addr is %x\n",i,(unsigned int)b);
mem_free(a);
mem_free(b);
}
*/
/*
for(i=0;i<1000;i++)
{
a=mem_alloc(10);
printf("+++++++++++++++the %d addr is %x\n",i,(unsigned int)a);
i++;
b=mem_alloc(10);
printf("+++++++++++++++the %d addr is %x\n",i,(unsigned int)b);
mem_free(a);
mem_free(b);
}
*/
/*
printf("the mem alloc is %x\n",(int)a);
//mem_free(a);
a=mem_alloc(9);
//printf("the mem alloc 9 ++++++++++++++++++is %x\n",(int)a);
mem_free(a);
a=mem_alloc(18);
printf("the mem alloc is %x\n",(int)a);
a=mem_alloc(100);
free(a);
*/
clock_t t1,t2,ta,tb;
t1=clock();
int t;
for(t=0;t<0x0ffffffa;t++)
{
a=mem_alloc(5);
mem_free(a);
}
t2=clock();
ta=t2-t1;
t1=clock();
for(t=0;t<0x0ffffffa;t++)
{
a=malloc(5);
free(a);
}
t2=clock();
tb=t2-t1;
printf("the time %ld\t%ld\n",ta,tb);
system("pause");
}
int create_sync_list()
{
#if MEM_POOL_ENABLE
mem_pool_init();
printf("######eable mem pool######\n");
#endif
local_sync = 0;
server_sync = 1;
finished_initial = 0;
LOCAL_FILE.path = NULL;
int i;
int num=asus_cfg.dir_number;
g_pSyncList = (sync_list **)malloc(sizeof(sync_list *)*num);
memset(g_pSyncList,0,sizeof(sync_list *)*num);
#if TOKENFILE
sighandler_finished = 0;
#endif
for(i=0;i<asus_cfg.dir_number;i++)
{
g_pSyncList[i] = (sync_list *)malloc(sizeof(sync_list));
memset(g_pSyncList[i],0,sizeof(sync_list));
g_pSyncList[i]->receve_socket = 0;
g_pSyncList[i]->have_local_socket = 0;
g_pSyncList[i]->first_sync = 1;
g_pSyncList[i]->no_local_root = 0;
g_pSyncList[i]->init_completed = 0;
#if TOKENFILE
g_pSyncList[i]->sync_disk_exist = 0;
#endif
// sprintf(g_pSyncList[i]->temp_path,"%s/.smartsync/dropbox",asus_cfg.prule[i]->base_path);
// my_mkdir_r(g_pSyncList[i]->temp_path); //have mountpath
// snprintf(g_pSyncList[i]->conflict_file,255,"%s/conflict_%s",
// g_pSyncList[i]->temp_path,asus_cfg.prule[i]->rooturl+1);
g_pSyncList[i]->ServerRootNode = NULL;
g_pSyncList[i]->OldServerRootNode = NULL;
g_pSyncList[i]->VeryOldServerRootNode = NULL;
g_pSyncList[i]->SocketActionList = queue_create();
g_pSyncList[i]->unfinished_list = create_action_item_head();
g_pSyncList[i]->up_space_not_enough_list = create_action_item_head();
g_pSyncList[i]->server_action_list = create_action_item_head();
g_pSyncList[i]->copy_file_list = create_action_item_head();
g_pSyncList[i]->access_failed_list = create_action_item_head();
if(asus_cfg.prule[i]->rule == 1)
{
g_pSyncList[i]->download_only_socket_head = create_action_item_head();
}
else
{
g_pSyncList[i]->download_only_socket_head = NULL;
}
#if TOKENFILE
tokenfile_info_tmp = tokenfile_info_start->next;
while(tokenfile_info_tmp != NULL)
{
//printf("asus_cfg.prule[%d]->rooturl=%s,asus_cfg.user=%s\n",i,asus_cfg.prule[i]->rooturl,asus_cfg.user);
//printf("tokenfile_info_tmp->folder=%s,tokenfile_info_tmp->url=%s\n",tokenfile_info_tmp->folder,tokenfile_info_tmp->url);
if(!strcmp(tokenfile_info_tmp->folder,asus_cfg.prule[i]->rooturl) && !strcmp(tokenfile_info_tmp->url,asus_cfg.user))
{
g_pSyncList[i]->sync_disk_exist = 1;
/*
fix below bug:
rm sync dir,change the sync dir,can not create sync dir
*/
if(access(asus_cfg.prule[i]->path,F_OK))
{
my_mkdir_r(asus_cfg.prule[i]->path);
}
break;
}
tokenfile_info_tmp = tokenfile_info_tmp->next;
}
#endif
}
}
TEST(DYHASH_INDEX_TEST2, dyhashindex) {
MEM_POOL* mem_pool = mem_pool_init(MB_SIZE);
struct dyhash_index_config config;
char dir_path[] = "/tmp/dyhash_index2";
config.is_full = 0;
config.row_limit = 2;
strcpy(config.work_space, dir_path);
struct dyhash_index_manager* dyhash_index = init(&config,dir_path);
int32_t ret = 0;
uint32_t docid = 0;
struct low_data_struct data;
data.data = mem_pool_malloc(mem_pool, strlen("hello world"));
memset(data.data, 0, strlen("hello world"));
strcpy((char*)data.data, "hello world");
data.len = strlen("hello world");
data.type = HI_TYPE_STRING;
strcpy((char*)data.data, "hello1world");
ret = dyhash_index_insert(dyhash_index,&data,docid);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello2world");
ret = dyhash_index_insert(dyhash_index,&data,docid);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello3world");
ret = dyhash_index_insert(dyhash_index,&data,docid);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello4world");
ret = dyhash_index_insert(dyhash_index,&data,docid);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello5world");
ret = dyhash_index_insert(dyhash_index,&data,docid);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello6world");
ret = dyhash_index_insert(dyhash_index,&data,docid);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello7world");
ret = dyhash_index_insert(dyhash_index,&data,docid);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello8world");
ret = dyhash_index_insert(dyhash_index,&data,docid);
ASSERT_EQ(0, ret);
strcpy((char*)data.data, "hello9world");
ret = dyhash_index_insert(dyhash_index,&data,docid);
ASSERT_EQ(0, ret);
uint32_t count = dyhash_index_count_query(dyhash_index, &data, mem_pool);
ASSERT_EQ(1,count);
}
