err_t spx_lazy_mmap_nb(SpxLogDelegate *log,char *ptr,int sock,size_t size,off_t begin){/*{{{*/
err_t err = 0;
size_t len = 0;
byte_t *ctx = spx_alloc(SpxKB,sizeof(byte_t),&err);
if(NULL == ctx){
SpxLogFmt2(log,SpxLogError,err,
"alloc buffer for lazy recv is fail.,msg size:%lld.",
SpxKB);
return err;
}
size_t totalsize = SpxMax(size,SpxKB);
size_t recvbytes = 0;
while(recvbytes < totalsize){
size_t recvs = SpxMin(SpxKB,(totalsize - recvbytes));
err = spx_read_nb(sock,ctx,recvs,&len);
if(0 != err ){
SpxLogFmt2(log,SpxLogError,err,
"lazy recv is fail.recvsize:%lld,realsize:%lld,writed size:%lld.",
recvs,len,recvbytes);
break;
}
len = 0;
memcpy(ptr + begin + recvbytes,ctx,recvs);
recvbytes += recvs;
memset(ctx,0,recvs);
}
SpxFree(ctx);
return err;
}/*}}}*/
err_t spx_lazy_recv_nb(SpxLogDelegate *log,int fd,int sock,size_t size){/*{{{*/
err_t err = 0;
size_t len = 0;
struct spx_msg *ctx = spx_msg_new(SpxKB,&err);
if(NULL == ctx){
SpxLogFmt2(log,SpxLogError,err,
"alloc msg for lazy recv is fail.msg size:%lld.",
SpxKB);
return err;
}
size_t totalsize = SpxMax(size,SpxKB);
size_t recvbytes = 0;
while(recvbytes < totalsize){
size_t recvs = SpxMin(SpxKB,(totalsize - recvbytes));
err = spx_read_to_msg_nb(sock,ctx,recvs,&len);
if(0 != err ){
SpxLogFmt2(log,SpxLogError,err,
"lazy recv is fail.recvsize:%lld,realsize:%lld,writed size:%lld.",
recvs,len,recvbytes);
break;
}
len = 0;
err = spx_write_from_msg_nb(fd,ctx,recvs,&len);
if(0 != err ){
SpxLogFmt2(log,SpxLogError,err,
"write by lazy recv is fail.recvsize:%lld,realsize:%lld,writed size:%lld.",
recvs,len,recvbytes);
break;
}
recvbytes += recvs;
spx_msg_clear(ctx);
}
SpxMsgFree(ctx);
return err;
}/*}}}*/
err_t spx_write_context_nb(SpxLogDelegate *log,int fd,struct spx_msg_context *ctx){/*{{{*/
err_t err = 0;
size_t len = 0;
struct spx_msg *hctx = spx_header_to_msg(ctx->header,SpxMsgHeaderSize,&err);
if(NULL == hctx){
SpxLog2(log,SpxLogError,err,
"header convert to msg-ctx is fail.");
return err;
}
err = spx_write_from_msg_nb(fd,hctx,SpxMsgHeaderSize,&len);
if(0 != err) {
SpxLogFmt2(log,SpxLogError,err,
"write header size:%lld,realsize:%lld.",
SpxMsgHeaderSize,len);
goto r1;
}
len = 0;
if(ctx->is_sendfile){
err = spx_write_from_msg_nb(fd,ctx->body,ctx->header->offset,&len);
if(0 != err){
SpxLogFmt2(log,SpxLogError,err,
"write leading-date of body buffer:%lld,realsize:%lld.",
ctx->header->offset,len);
goto r1;
}
len = 0;
err = spx_sendfile(fd,ctx->sendfile_fd,ctx->sendfile_begin,ctx->sendfile_size,&len);
if(0 != err ){
SpxLogFmt2(log,SpxLogError,err,
"sendfile size:%lld,realsize:%lld.",
ctx->sendfile_size,len);
goto r1;
}
} else {
err = spx_write_from_msg_nb(fd,ctx->body,ctx->header->bodylen,&len);
if(0 != err ){
SpxLogFmt2(log,SpxLogError,err,
"write body buffer:%lld,realsize:%lld.",
ctx->header->bodylen,len);
goto r1;
}
}
r1:
if(NULL != hctx){
SpxMsgFree(hctx);
}
return err;
}/*}}}*/
spx_private err_t ydb_storage_query_remote(SpxLogDelegate *log,
struct ydb_tracker *t,string_t groupname,
string_t machineid,string_t syncgroup){/*{{{*/
err_t err = 0;
struct spx_job_context *sjc = t->sjc;
int fd = spx_socket_new(&err);
if(0 >= fd){
SpxLog2(log,SpxLogError,err,"create query sync socket fd is fail.");
return err;
}
if(0 != (err = spx_set_nb(fd))){
SpxLog2(log,SpxLogError,err,"set socket nonblacking is fail.");
goto r1;
}
if(0 != (err = spx_socket_set(fd,SpxKeepAlive,SpxAliveTimeout,\
SpxDetectTimes,SpxDetectTimeout,\
SpxLinger,SpxLingerTimeout,\
SpxNodelay,\
true,30))){
SpxLog2(log,SpxLogError,err,"set socket operator is fail.");
goto r1;
}
if(0 != (err = spx_socket_connect(fd,t->host.ip,t->host.port))){
SpxLogFmt2(log,SpxLogError,err,\
"conntect to tracker:%s:%d is fail.",\
t->host.ip,t->host.port);
goto r1;
}
struct spx_msg_header *writer_header = NULL;
writer_header = spx_alloc_alone(sizeof(*writer_header),&err);
if(NULL == writer_header){
SpxLog2(log,SpxLogError,err,\
"alloc writer header is fail.");
goto r1;
}
sjc->writer_header = writer_header;
writer_header->version = YDB_VERSION;
writer_header->protocol = YDB_QUERY_SYNC_STORAGES;
writer_header->bodylen = YDB_GROUPNAME_LEN + YDB_MACHINEID_LEN \
+ YDB_SYNCGROUP_LEN ;
struct spx_msg *ctx = spx_msg_new(writer_header->bodylen,&err);
if(NULL == ctx){
SpxLog2(log,SpxLogError,err,\
"alloc writer body is fail.");
goto r1;
}
sjc->writer_body_ctx = ctx;
spx_msg_pack_fixed_string(ctx,groupname,YDB_GROUPNAME_LEN);
spx_msg_pack_fixed_string(ctx,machineid,YDB_MACHINEID_LEN);
spx_msg_pack_fixed_string(ctx,syncgroup,YDB_SYNCGROUP_LEN);
sjc->fd = fd;
spx_nio_regedit_writer(sloop,sjc->fd,sjc);
return err;
r1:
SpxClose(fd);
return err;
}/*}}}*/
spx_private bool_t ydb_storage_get_remote(struct ydb_storage_configurtion *c,\
struct spx_job_context_transport *arg){/*{{{*/
err_t err = 0;
struct spx_vector_iter *iter = spx_vector_iter_init(c->trackers ,&err);
if(NULL == iter){
SpxLog2(c->log,SpxLogError,err,\
"init the trackers iter is fail.");
return false;
}
struct ydb_tracker *t = NULL;
while(NULL != (t = spx_vector_iter_next(iter))){
if(NULL == t->sjc){
t->sjc = (struct spx_job_context *) spx_job_context_new(0,arg,&err);
if(NULL == t->sjc){
SpxLog2(c->log,SpxLogError,err,"alloc heartbeat nio context is fail.");
continue;
}
}
err = ydb_storage_query_remote(c->log,t,c->groupname,\
c->machineid,c->syncgroup);
if(0 != err){
t->sjc->err = err;
SpxLogFmt2(t->sjc->log,SpxLogError,err,\
"query sync storage to tracker %s:%d is fail.",\
t->host.ip,t->host.port);
}
}
spx_vector_iter_free(&iter);
return true;
}/*}}}*/
struct spx_msg_header *spx_read_header_nb(SpxLogDelegate *log,int fd,err_t *err){/*{{{*/
size_t len = 0;
struct spx_msg *hbuff = spx_msg_new(SpxMsgHeaderSize,err);
if(NULL == hbuff){
SpxLog2(log,SpxLogError,*err,
"new msg-ctx for header is fail.");
return NULL;
}
*err = spx_read_to_msg_nb(fd,hbuff,SpxMsgHeaderSize,&len);
if(0 != *err){
SpxLogFmt2(log,SpxLogError,*err,
"recv header buff:%d,realsize:%d.",
SpxMsgHeaderSize,len);
SpxMsgFree(hbuff);
return NULL;
}
struct spx_msg_header *h = spx_msg_to_header(hbuff,err);
if(NULL == h){
SpxLog2(log,SpxLogError,*err,
"convert msg-ctx to header is fail.");
SpxMsgFree(hbuff);
return NULL;
}
return h;
}/*}}}*/
struct spx_msg *spx_read_body_nb(SpxLogDelegate *log,int fd,size_t size,err_t *err){/*{{{*/
size_t len = 0;
struct spx_msg *ctx = spx_msg_new(size,err);
if(NULL == ctx){
SpxLog2(log,SpxLogError,*err,
"new msg-ctx for header is fail.");
return NULL;
}
*err = spx_read_to_msg_nb(fd,ctx,size,&len);
if(0 != *err){
SpxLogFmt2(log,SpxLogError,*err,
"read body buffer:%lld realsize:%lld.",
size,len);
SpxMsgFree(ctx);
return NULL;
}
return ctx;
}/*}}}*/
err_t ydb_storage_dio_delete(struct ev_loop *loop,\
struct ydb_storage_dio_context *dc){/*{{{*/
err_t err = 0;
struct spx_task_context *tc = dc->tc;
struct spx_job_context *jc = dc->jc;
struct ydb_storage_configurtion *c = jc->config;
struct spx_msg *ctx = jc->reader_body_ctx;
size_t len = jc->reader_header->bodylen;
dc->rfid = spx_msg_unpack_string(ctx,len,&(err));
if(NULL == dc->rfid){
SpxLogFmt2(c->log,SpxLogError,err,\
"unpack the fid from client:%s is fail.",
jc->client_ip);
goto r1;
}
if(0 != ( err = ydb_storage_dio_parser_fileid(jc->log,dc->rfid,
&(dc->groupname),&(dc->machineid),&(dc->syncgroup),
&(dc->issinglefile),&(dc->mp_idx),&(dc->p1),
&(dc->p2),&(dc->tidx),&(dc->file_createtime),
&(dc->rand),&(dc->begin),&(dc->realsize),
&(dc->totalsize),&(dc->ver),&(dc->opver),
&(dc->lastmodifytime),&(dc->hashcode),
&(dc->has_suffix),&(dc->suffix)))){
SpxLogFmt2(dc->log,SpxLogError,err,\
"parser fid:%s from client:%s is fail.",
dc->rfid,jc->client_ip);
goto r1;
}
dc->filename = ydb_storage_dio_make_filename(dc->log,dc->issinglefile,
c->mountpoints,
dc->mp_idx,
dc->p1,dc->p2,
dc->machineid,dc->tidx,dc->file_createtime,
dc->rand,dc->suffix,&err);
if(NULL == dc->filename){
SpxLogFmt2(dc->log,SpxLogError,err,\
"make filename with fid:%s from client:%s is fail.",
dc->rfid,jc->client_ip);
goto r1;
}
if(!SpxFileExist(dc->filename)) {
SpxLogFmt1(dc->log,SpxLogWarn,\
"deleting-file:%s is not exist.request from:%s.",
dc->filename,jc->client_ip);
goto r1;
}
if(dc->issinglefile){
if(0 != remove(dc->filename)){
err = errno;
SpxLogFmt2(dc->log,SpxLogError,err,\
"delete file :%s is fail.request from:%s.",
dc->filename,jc->client_ip);
}
YdbStorageBinlogDeleteWriter(dc->rfid);
struct ydb_storage_mountpoint *mp = spx_list_get(c->mountpoints, dc->mp_idx);
mp->last_modify_time = spx_now();
goto r1;
} else {
spx_dio_regedit_async(&(dc->async),
ydb_storage_dio_do_delete_form_chunkfile,dc);
ev_async_start(loop,&(dc->async));
ev_async_send(loop,&(dc->async));
}
return err;
r1:
spx_task_pool_push(g_spx_task_pool,tc);
ydb_storage_dio_pool_push(g_ydb_storage_dio_pool,dc);
jc->writer_header = (struct spx_msg_header *)
spx_alloc_alone(sizeof(*(jc->writer_header)),&err);
if(NULL == jc->writer_header){
SpxLog2(dc->log,SpxLogError,err,\
"new response header is fail."
"no notify client and push jc force.");
spx_job_pool_push(g_spx_job_pool,jc);
return err;
}
jc->writer_header->protocol = jc->reader_header->protocol;
jc->writer_header->bodylen = 0;
jc->writer_header->version = YDB_VERSION;
jc->writer_header->err = err;
jc->err = err;
jc->moore = SpxNioMooreResponse;
size_t idx = spx_network_module_wakeup_idx(jc);
struct spx_thread_context *threadcontext =
spx_get_thread(g_spx_network_module,idx);
jc->tc = threadcontext;
SpxModuleDispatch(spx_network_module_wakeup_handler,jc);
return 0;
}/*}}}*/
err_t ydb_storage_dio_delete_context_from_chunkfile(
struct ydb_storage_configurtion *c,
string_t fname,
u64_t cbegin,
u64_t ctotalsize,
u32_t copver,
u32_t cver,
u64_t clastmodifytime,
u64_t crealsize,
u64_t lastmodifytime){/*{{{*/
err_t err = 0;
struct spx_msg *ioctx = NULL;
int fd = 0;
char *mptr = NULL;
string_t io_suffix = NULL;
string_t io_hashcode = NULL;
bool_t io_isdelete = false;
u32_t io_opver = 0;
u32_t io_ver = 0;
u64_t io_createtime = 0;
u64_t io_lastmodifytime = 0;
u64_t io_totalsize = 0;
u64_t io_realsize = 0;
u32_t unit = (int) cbegin / c->pagesize;
u64_t begin = unit * c->pagesize;
u64_t offset = cbegin - begin;
u64_t len = offset + ctotalsize;
fd = open(fname,O_RDWR,SpxFileMode);
if(0 == fd){
err = errno;
SpxLogFmt2(c->log,SpxLogError,err,\
"open chunkfile:%s is fail.",
fname);
goto r1;
}
mptr = mmap(NULL,\
len,PROT_READ | PROT_WRITE ,\
MAP_SHARED,fd,begin);
if(MAP_FAILED == mptr){
err = errno;
SpxLogFmt2(c->log,SpxLogError,err,\
"mmap chunkfile:%s with begin:%lld,length:%lld is fail.",
fname,begin,len);
goto r1;
}
ioctx = spx_msg_new(YDB_CHUNKFILE_MEMADATA_SIZE,&err);
if(NULL == ioctx){
SpxLog2(c->log,SpxLogError,err,\
"alloc metedata ioctx is fail.");
goto r1;
}
if(0 != (err = spx_msg_pack_ubytes(ioctx,
((ubyte_t *) (mptr+ offset)),
YDB_CHUNKFILE_MEMADATA_SIZE))){
SpxLog2(c->log,SpxLogError,err,\
"read metedata to ioctx is fail.");
goto r1;
}
spx_msg_seek(ioctx,0,SpxMsgSeekSet);
err = ydb_storage_dio_parser_metadata(c->log,ioctx,
&io_isdelete,&io_opver,
&io_ver,&io_createtime,
&io_lastmodifytime,&io_totalsize,&io_realsize,
&io_suffix,&io_hashcode);
if(0 != err){
SpxLog2(c->log,SpxLogError,err,\
"unpack metedate ioctx is fail.");
goto r1;
}
if(io_isdelete){
SpxLogFmt1(c->log,SpxLogError,
"the file in the chunkfile:%s "
"with begin:%lld totalsize:%lld is deleted.",
fname,cbegin,ctotalsize);
err = ENOENT;
goto r1;
}
if(copver != io_opver || cver != io_ver
|| clastmodifytime != io_lastmodifytime
|| ctotalsize != io_totalsize
|| crealsize != io_realsize){
SpxLogFmt1(c->log,SpxLogError,
"the file in the chunkfile:%s "
"with begin:%lld totalsize:%lld is not the deleting-file.",
fname,cbegin,ctotalsize);
err = ENOENT;
goto r1;
}
spx_msg_seek(ioctx,0,SpxMsgSeekSet);
spx_msg_pack_true(ioctx);//isdelete
spx_msg_pack_u32(ioctx,copver + 1);
spx_msg_pack_u32(ioctx,YDB_VERSION);
spx_msg_seek(ioctx,sizeof(u64_t),SpxMsgSeekCurrent);//jump createtime
spx_msg_pack_u64(ioctx,lastmodifytime);
memcpy(mptr + offset,ioctx->buf,YDB_CHUNKFILE_MEMADATA_SIZE);
r1:
if(NULL != ioctx){
SpxMsgFree(ioctx);
}
if(NULL != mptr){
munmap(mptr,len);
}
if(0 < fd){
SpxClose(fd);
}
if(NULL != io_hashcode){
SpxStringFree(io_hashcode);
}
if(NULL != io_suffix){
SpxStringFree(io_suffix);
}
return err;
}/*}}}*/
void ydb_storage_dio_do_delete_form_chunkfile(
struct ev_loop *loop,ev_async *w,int revents){/*{{{*/
ev_async_stop(loop,w);
err_t err = 0;
struct ydb_storage_dio_context *dc = (struct ydb_storage_dio_context *)
w->data;
struct spx_task_context *tc = dc->tc;
struct spx_job_context *jc = dc->jc;
struct ydb_storage_configurtion *c = jc->config;
if(0 != (err = ydb_storage_dio_delete_context_from_chunkfile(
c,dc->filename,dc->begin,dc->totalsize,
dc->opver,dc->ver,dc->lastmodifytime,
dc->realsize,spx_now()))){
SpxLogFmt2(dc->log,SpxLogError,err,
"delete context begin:%lld,realsize:%lld,totalsize:%lld "
"form chunkfile:%s is fail.",
dc->begin,dc->realsize,dc->totalsize,
dc->filename);
goto r1;
}
YdbStorageBinlogDeleteWriter(dc->rfid);
struct ydb_storage_mountpoint *mp = spx_list_get(c->mountpoints, dc->mp_idx);
mp->last_modify_time = spx_now();
struct spx_msg_header *wh = (struct spx_msg_header *) \
spx_alloc_alone(sizeof(*wh),&err);
if(NULL == wh){
SpxLogFmt2(dc->log,SpxLogError,err,
"delete context begin:%lld,realsize:%lld,totalsize:%lld "
"form chunkfile:%s is success bug new response header is fail.",
dc->begin,dc->realsize,dc->totalsize,
dc->filename);
goto r1;
}
jc->writer_header = wh;
wh->version = YDB_VERSION;
wh->protocol = YDB_C2S_DELETE;
wh->offset = 0;
wh->bodylen = 0;
err = 0;
goto r2;
r1:
jc->writer_header = (struct spx_msg_header *)
spx_alloc_alone(sizeof(*(jc->writer_header)),&err);
if(NULL == jc->writer_header){
SpxLog2(dc->log,SpxLogError,err,\
"new response header is fail."
"no notify client and push jc force.");
spx_task_pool_push(g_spx_task_pool,tc);
ydb_storage_dio_pool_push(g_ydb_storage_dio_pool,dc);
spx_job_pool_push(g_spx_job_pool,jc);
return;
}
jc->writer_header->protocol = jc->reader_header->protocol;
jc->writer_header->bodylen = 0;
jc->writer_header->version = YDB_VERSION;
jc->writer_header->err = err;
r2:
spx_task_pool_push(g_spx_task_pool,tc);
ydb_storage_dio_pool_push(g_ydb_storage_dio_pool,dc);
jc->err = err;
jc->moore = SpxNioMooreResponse;
size_t idx = spx_network_module_wakeup_idx(jc);
struct spx_thread_context *threadcontext =
spx_get_thread(g_spx_network_module,idx);
jc->tc = threadcontext;
SpxModuleDispatch(spx_network_module_wakeup_handler,jc);
return;
}/*}}}*/
void logdb_tracker_config_line_parser_handle(string_t line,void *config,err_t *err){
struct logdb_tracker_configurtion *c = (struct logdb_tracker_configurtion *) config;
int count = 0;
string_t *kv = spx_string_splitlen(line,\
spx_string_len(line),"=",strlen("="),&count,err);
if(NULL == kv){
return;
}
spx_string_rtrim(*kv," ");
if(2 == count){
spx_string_ltrim(*(kv + 1)," ");
}
//ip
if(0 == spx_string_casecmp(*kv,"ip")){
if(2 == count && !SpxStringIsEmpty(*(kv + 1))){
if(spx_socket_is_ip(*(kv + 1))){
c->ip =spx_string_dup(*(kv + 1),err);
if(NULL == c->ip){
SpxLog2(c->log,SpxLogError,*err,\
"dup the ip from config operator is fail.");
}
} else {
string_t ip = spx_socket_getipbyname(*(kv + 1),err);
if(NULL == ip){
SpxLogFmt2(c->log,SpxLogError,*err,\
"get local ip by hostname:%s is fail.",*(kv + 1));
goto r1;
}
c->ip = ip;
}
} else{
SpxLog1(c->log,SpxLogWarn,"use the default ip.");
string_t ip = spx_socket_getipbyname(NULL,err);
if(NULL == ip){
SpxLog2(c->log,SpxLogError,*err,\
"get local ip by default hostname is fail.");
goto r1;
}
c->ip = ip;
}
goto r1;
}
//port
if(0 == spx_string_casecmp(*kv,"port")){
if(1 == count || SpxStringIsEmpty(*(kv + 1))){
SpxLogFmt1(c->log,SpxLogWarn,"the port is use default:%d.",c->port);
goto r1;
}
i32_t port = strtol(*(kv + 1),NULL,10);
if(ERANGE == port) {
SpxLog1(c->log,SpxLogError,"bad the configurtion item of port.");
goto r1;
}
c->port = port;
goto r1;
}
//timeout
if(0 == spx_string_casecmp(*kv,"timeout")){
if(1 == count || SpxStringIsEmpty(*(kv + 1))){
SpxLogFmt1(c->log,SpxLogWarn,"use default timeout:%d.",c->timeout);
} else {
u32_t timeout = logdb_tracker_configurtion_timespan_convert(c->log,*(kv + 1),
SpxSecondTick,
"bad the configurtion item of timeout.",err);
if(0 != *err) {
SpxLog1(c->log,SpxLogError,"bad the configurtion item of timeout.");
goto r1;
}
c->timeout = timeout;
}
goto r1;
}
//waitting
if(0 == spx_string_casecmp(*kv,"waitting")){
if(1 == count || SpxStringIsEmpty(*(kv + 1))){
SpxLogFmt1(c->log,SpxLogWarn,"use default waitting:%d.",c->waitting);
} else {
u32_t waitting = logdb_tracker_configurtion_timespan_convert(c->log,*(kv + 1),
SpxSecondTick,
"bad the configurtion item of waitting.",err);
if(0 != *err) {
SpxLog1(c->log,SpxLogError,"bad the configurtion item of waitting.");
goto r1;
}
c->waitting = waitting;
}
goto r1;
}
//trytimes
if(0 == spx_string_casecmp(*kv,"trytim")){
if(1 == count || SpxStringIsEmpty(*(kv + 1))){
SpxLogFmt1(c->log,SpxLogWarn,"the trytimes is use default:%d.",c->trytimes);
goto r1;
}
i32_t trytimes = strtol(*(kv + 1),NULL,10);
if(ERANGE == trytimes) {
SpxLog1(c->log,SpxLogError,"bad the configurtion item of trytim.");
goto r1;
}
c->trytimes = trytimes;
goto r1;
}
//daemon
if(0 == spx_string_casecmp(*kv,"daemon")){
if(1 == count || SpxStringIsEmpty(*(kv + 1))){
SpxLogFmt1(c->log,SpxLogWarn,"instance use default daemon:%d.",c->daemon);
} else {
string_t s = *(kv + 1);
if(0 == spx_string_casecmp(s,spx_bool_desc[false])){
c->daemon = false;
} else if(0 == spx_string_casecmp(s,spx_bool_desc[true])){
c->daemon = true;
} else {
c->daemon = true;
}
}
goto r1;
}
if(0 == spx_string_casecmp(*kv,"stacksize")){
if(1 == count){
SpxLogFmt1(c->log,SpxLogWarn,"stacksize use default:%lld.",c->stacksize);
} else {
u64_t size = logdb_tracker_configurtion_iosize_convert(
c->log,*(kv + 1),SpxKB,
"convert stacksize is fail.",err);
if(0 != *err){
goto r1;
}
c->stacksize = size;
}
goto r1;
}
//network_module_thread_size
if(0 == spx_string_casecmp(*kv,"network_module_thread_size")){
if(1 == count || SpxStringIsEmpty(*(kv + 1))){
SpxLogFmt1(c->log,SpxLogWarn,"network module thread size use default:%d.",c->network_module_thread_size);
} else {
u32_t network_module_thread_size = strtol(*(kv + 1),NULL,10);
if(ERANGE == network_module_thread_size) {
SpxLog1(c->log,SpxLogError,"bad the configurtion item of network_module_thread_size.");
goto r1;
}
c->network_module_thread_size = network_module_thread_size;
}
goto r1;
}
//notifier_module_thread_size
// if(0 == spx_string_casecmp(*kv,"notifier_module_thread_size")){
// if(1 == count || SpxStringIsEmpty(*(kv + 1))){
// SpxLogFmt1(c->log,SpxLogWarn,
// "notifier module thread size use default:%d.",c->notifier_module_thread_size);
// } else {
// u32_t notifier_module_thread_size = strtol(*(kv + 1),NULL,10);
// if(ERANGE == notifier_module_thread_size) {
// SpxLog1(c->log,SpxLogError,"bad the configurtion item of notifier_module_thread_size.");
// goto r1;
// }
// c->notifier_module_thread_size = notifier_module_thread_size;
// }
// goto r1;
// }
//task_module_thread_size
if(0 == spx_string_casecmp(*kv,"task_module_thread_size")){
if(1 == count || SpxStringIsEmpty(*(kv + 1))){
SpxLogFmt1(c->log,SpxLogWarn,\
"task module thread size use default:%d.",c->task_module_thread_size);
} else {
u32_t task_module_thread_size = strtol(*(kv + 1),NULL,10);
if(ERANGE == task_module_thread_size) {
SpxLog1(c->log,SpxLogError,"bad the configurtion item of task_module_thread_size.");
goto r1;
}
c->task_module_thread_size = task_module_thread_size;
}
goto r1;
}
//context size
if(0 == spx_string_casecmp(*kv,"context_size")){
if(1 == count || SpxStringIsEmpty(*(kv + 1))){
SpxLogFmt1(c->log,SpxLogWarn,\
"context size use default:%d.",c->context_size);
} else {
u32_t context_size = strtol(*(kv + 1),NULL,10);
if(ERANGE == context_size) {
SpxLog1(c->log,SpxLogError,"bad the configurtion item of context_size.");
goto r1;
}
c->context_size = context_size;
}
goto r1;
}
//heartbeat
if(0 == spx_string_casecmp(*kv,"heartbeat")){
if(1 == count){
SpxLogFmt1(c->log,SpxLogWarn,\
"heartbeat use default:%d.",c->heartbeat);
} else {
u32_t heartbeat = logdb_tracker_configurtion_timespan_convert(
c->log,*(kv + 1),SpxSecondTick,
"bad configurtion item of heartheat.",err);
if(0 != *err) {
goto r1;
}
c->heartbeat = heartbeat;
}
goto r1;
}
//basepath
if(0 == spx_string_casecmp(*kv,"basepath")){
if(1 == count || SpxStringIsEmpty(*(kv + 1))){
SpxLog1(c->log,SpxLogError,\
"bad the configurtion item of basepath.and basepath is empty.");
goto r1;
}
c->basepath = spx_string_dup(*(kv + 1),err);
if(NULL == c->basepath){
SpxLog2(c->log,SpxLogError,*err,\
"dup the string for basepath is fail.");
}
goto r1;
}
//logpath
if(0 == spx_string_casecmp(*kv,"logpath")){
if(1 == count || SpxStringIsEmpty(*(kv + 1))){
c->logpath = spx_string_new("/opt/ydb/log/tracker/",err);
if(NULL == c->logpath){
SpxLog2(c->log,SpxLogError,*err,\
"alloc default logpath is fail.");
goto r1;
}
SpxLogFmt1(c->log,SpxLogWarn,\
"logpath use default:%s.",c->logpath);
}else {
c->logpath = spx_string_dup(*(kv + 1),err);
if(NULL == c->logpath){
SpxLog2(c->log,SpxLogError,*err,\
"dup the string for logpath is fail.");
}
}
goto r1;
}
//logprefix
if(0 == spx_string_casecmp(*kv,"logprefix")){
if(1 == count || SpxStringIsEmpty(*(kv + 1))){
c->logprefix = spx_string_new("ydb-tracker",err);
if(NULL == c->logprefix){
SpxLog2(c->log,SpxLogError,*err,\
"alloc default logprefix is fail.");
goto r1;
}
SpxLogFmt1(c->log,SpxLogWarn,\
"logprefix use default:%s.",c->logprefix);
} else {
c->logprefix = spx_string_dup(*(kv + 1),err);
if(NULL == c->logprefix){
SpxLog2(c->log,SpxLogError,*err,\
"dup the string for logprefix is fail.");
}
}
goto r1;
}
//logsize
if(0 == spx_string_casecmp(*kv,"logsize")){
if(1 == count){
SpxLogFmt1(c->log,SpxLogWarn,\
"logsize use default:%lld.",c->logsize);
} else {
u64_t size = logdb_tracker_configurtion_iosize_convert(
c->log,*(kv + 1),SpxMB,
"convert logsize is fail.",err);
if(0 != *err){
goto r1;
}
c->logsize = size;
}
goto r1;
}
//loglevel
if(0 == spx_string_casecmp(*kv,"loglevel")){
if(1 == count || SpxStringIsEmpty(*(kv + 1))){
SpxLogFmt1(c->log,SpxLogWarn,\
"loglevel use default:%s",SpxLogDesc[c->loglevel]);
} else {
string_t s = *(kv + 1);
if(0 == spx_string_casecmp(s,"debug")){
c->loglevel = SpxLogDebug;
} else if(0 == spx_string_casecmp(s,"info")){
c->loglevel = SpxLogInfo;
}else if(0 == spx_string_casecmp(s,"warn")){
c->loglevel = SpxLogWarn;
}else if(0 == spx_string_casecmp(s,"error")){
c->loglevel = SpxLogError;
} else {
c->loglevel = SpxLogInfo;
}
}
goto r1;
}
//balance
if(0 == spx_string_casecmp(*kv,"balance")){
if(1 == count || SpxStringIsEmpty(*(kv + 1))){
SpxLogFmt1(c->log,SpxLogWarn,\
"mountpoint balance use default:%s",\
tracker_balance_mode_desc[c->balance]);
goto r1;
}
string_t s = *(kv + 1);
if(0 == spx_string_casecmp(s,\
tracker_balance_mode_desc[YDB_TRACKER_BALANCE_LOOP])){
c->balance = YDB_TRACKER_BALANCE_LOOP;
} else if(0 == spx_string_casecmp(s,\
tracker_balance_mode_desc[YDB_TRACKER_BALANCE_TURN])){
c->balance = YDB_TRACKER_BALANCE_TURN;
}else if(0 == spx_string_casecmp(s,\
tracker_balance_mode_desc[YDB_TRACKER_BALANCE_MAXDISK])){
c->balance = YDB_TRACKER_BALANCE_MAXDISK;
}else if(0 == spx_string_casecmp(s,\
tracker_balance_mode_desc[YDB_TRACKER_BALANCE_MASTER])){
c->balance = YDB_TRACKER_BALANCE_MASTER;
} else {
c->balance = YDB_TRACKER_BALANCE_LOOP;
}
goto r1;
}
//master
if(0 == spx_string_casecmp(*kv,"master")){
if(1 == count || SpxStringIsEmpty(*(kv + 1))){
SpxLog1(c->log,SpxLogWarn,
"disable the master.");
goto r1;
}
c->master = spx_string_dup(*(kv + 1),err);
if(NULL == c->master){
SpxLog2(c->log,SpxLogError,*err,\
"dup master is fail.");
}
goto r1;
}
r1:
spx_string_free_splitres(kv,count);
return;
}
