void WD_SYSTEM performtest_handle ( u32 delay_tm, const u8 *p_url, u32 tree_num, u8 request_num ) { u8 m = 0; performtest_init(delay_tm,tree_num,request_num); performtest_setSysState(SYS_HSK); wilddog = wilddog_initWithUrl((Wilddog_Str_T*)p_url); if(0 == wilddog) { return; } perform_count = 0; wilddog_debug(); performtest_setSysState(SYS_AUTHRECV); wilddog_debug(); performtest_timeReset(); wilddog_debug(); os_timer_disarm(&test_timer2); os_timer_setfn(&test_timer2, (os_timer_func_t *)perform_sync, NULL); os_timer_arm(&test_timer2, 1000, 0); return; }
STATIC void test_onDeleteFunc(void* arg, Wilddog_Return_T err) { if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("delete failed!, err = %d",err); return; } wilddog_debug("delete success!"); *(BOOL*)arg = TRUE; return; }
STATIC void test_onSetFunc(void* arg, Wilddog_Return_T err) { if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("set error!err = %d", err); return; } wilddog_debug("set success!"); *(BOOL*)arg = TRUE; return; }
STATIC void removeValue_callback(void* arg, Wilddog_Return_T err) { if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("removeValue failed!"); return ; } wilddog_debug("removeValue success!"); *(BOOL*)arg = TRUE; return; }
STATIC void WD_SYSTEM test_setValueFunc(void* arg, Wilddog_Return_T err) { if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("setValue error!"); return; } wilddog_debug("setValue success!"); *(BOOL*)arg = TRUE; return; }
STATIC void push_callback(u8 *p_path,void* arg, Wilddog_Return_T err) { if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("push failed"); return; } wilddog_debug("new path is %s", p_path); *(BOOL*)arg = TRUE; return; }
STATIC void test_onPushFunc(u8 *p_path,void* arg, Wilddog_Return_T err) { if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("push failed! err = %d",err); return; } wilddog_debug("new path is %s", p_path); *(BOOL*)arg = TRUE; return; }
void set_receive_time(guu_is_wilddog_t *gwd) { //set the unix time stamp in the tree we got char time_buf[14]; int len; Wilddog_Node_T *node; node = wilddog_node_find(gwd->snapshot_clone,"received"); if(node !=NULL) { gettimeofday(&tv, NULL); len = sprintf(time_buf,"%ld", tv.tv_sec); //printf("%s %d\n",time_buf,len); if( wilddog_node_setValue(node,time_buf,len) != 0) { wilddog_debug("setValue failed\n"); } } wilddog_setValue(gwd->wd,gwd->snapshot_clone,setvalue_cb,(void*)gwd); }
STATIC void stab_settest_judge(Wilddog_Node_T* p_snapshot,void* arg) { int len; Stab_Setdata_T *p_set1 = (Stab_Setdata_T*)arg; if(p_snapshot !=0 && arg != 0) { Stab_Setdata_T *p_set = (Stab_Setdata_T*)arg; if( 0 == strcmp( (const char*)wilddog_node_getValue(p_snapshot,&len), \ (const char*)p_set->data)) { stab_settest_getsuccess++; return ; } else { wilddog_debug("truevalue:%s,getvalue:%s\n", \ p_set1->data,wilddog_node_getValue(p_snapshot,&len)); stab_settest_fault++; } } return ; }
STATIC void test_onQueryFunc( const Wilddog_Node_T* p_snapshot, void* arg, Wilddog_Return_T err) { if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("query error!err = %d", err); return; } wilddog_debug("query success!"); if(p_snapshot) { *(Wilddog_Node_T**)arg = wilddog_node_clone(p_snapshot); } return; }
STATIC void addObserver_callback ( const Wilddog_Node_T* p_snapshot, void* arg, Wilddog_Return_T err ) { *(BOOL*)arg = TRUE; if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("addObserver failed!"); return; } wilddog_debug("Observe new data!"); wilddog_debug_printnode(p_snapshot); printf("\n"); return; }
STATIC void addObserver_callback_b ( const Wilddog_Node_T* p_snapshot, void* arg, Wilddog_Return_T err ) { *(BOOL*)arg = TRUE; if((err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED ) && err != WILDDOG_ERR_RECONNECT) { wilddog_debug(" B addObserver_callback2 failed! error code = %d",err); return; } wilddog_debug(" get B Observe !"); wilddog_debug_printnode(p_snapshot); printf("\n"); return; }
STATIC void onDis_callback(void* arg, Wilddog_Return_T err) { if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("push failed"); return; } *(BOOL*)arg = TRUE; return; }
Wilddog_T init_wilddog( char*url) { Wilddog_T _wd; _wd = wilddog_initWithUrl((Wilddog_Str_T *)url); if(0 == _wd) { wilddog_debug("new wilddog failed! %s\n",url); return 0; } return _wd; }
STATIC void stab_settest_serialSetValueFunc(void* arg, Wilddog_Return_T err) { stab_get_recvErr(err,STABTEST_CMD_SET); Stab_Setdata_T *p_set = (Stab_Setdata_T*)arg; stab_settest_setsuccess--; if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { p_set->setfault = 1; #if STAB_DEBUG == 1 wilddog_debug("set fault key = %s;data = %s ",p_set->key,p_set->data); #endif } else #if STAB_DEBUG == 1 wilddog_debug("set success key = %s;data = %s ",p_set->key,p_set->data); #endif return; }
STATIC void getValue_callback ( const Wilddog_Node_T* p_snapshot, void* arg, Wilddog_Return_T err ) { *(BOOL*)arg = TRUE; wilddog_debug("<><> get return code : %d",err); if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("getValue fail!"); return; } if(p_snapshot) wilddog_debug_printnode(p_snapshot); printf("\ngetValue success!\n"); return; }
STATIC void auth_callback ( void* arg, Wilddog_Return_T err ) { *(BOOL*)arg = TRUE; if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("auth failed!;error =%d \n",err); return; } }
STATIC void multiple_getValueFunc ( const Wilddog_Node_T* p_snapshot, void* arg, Wilddog_Return_T err ) { Multiple_client_T *p_client = (Multiple_client_T*)arg; p_client->d_recvFlag = 1; printf("Get : error: %d %s %p\n",err,p_client->p_host, p_snapshot); if(p_snapshot) wilddog_debug_printnode(p_snapshot); if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) return; else p_client->d_getResult = (u8) multiple_judge(p_snapshot,p_client->p_host); wilddog_debug(); }
void setvalue_cb(void* arg, Wilddog_Return_T err) { guu_is_wilddog_t *ptr_gwd; ptr_gwd = (guu_is_wilddog_t*)arg; ptr_gwd->setvalue_finished = TRUE; if(ptr_gwd->snapshot_clone !=NULL) { wilddog_node_delete(ptr_gwd->snapshot_clone); ptr_gwd->snapshot_clone = NULL; } if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("set error!"); return; } return; }
STATIC void test_onObserveFunc( const Wilddog_Node_T* p_snapshot, void* arg, Wilddog_Return_T err) { *(BOOL*)arg = TRUE; if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("observe failed! err = %d", err); return; } printf("*******************************************\n"); printf("Observe the data:\n"); wilddog_debug_printnode(p_snapshot); printf("\n"); printf("*******************************************\n"); printf("\n\n"); return; }
Wilddog_T check_finished( guu_is_wilddog_t* gwd) // in a while(1) loop { if(TRUE == gwd->observer_finished) { //wilddog_debug("get new data %d times!", count++); gwd->observer_finished = FALSE; set_receive_time(gwd); if(gwd->count > 0) { //wilddog_debug("off the data!"); wilddog_removeObserver(gwd->wd, WD_ET_VALUECHANGE); return 0; } } if(TRUE == gwd->setvalue_finished) { gwd->setvalue_finished = FALSE; wilddog_debug("set success"); } return 1; }
void Observer_CB( const Wilddog_Node_T* p_snapshot, void* arg,Wilddog_Return_T err) { guu_is_wilddog_t *ptr_gwd; ptr_gwd = (guu_is_wilddog_t*)arg; ptr_gwd->observer_finished = TRUE; if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("addObserver failed!"); return; } ptr_gwd->snapshot_clone = wilddog_node_clone(p_snapshot); /* */ // wilddog_debug("addObserver data!"); ptr_gwd->node_val = wilddog_debug_n2jsonString(p_snapshot); //printf("%s\n",ptr_gwd->node_val); #ifdef INLISP if(ptr_gwd->node_val !=NULL) { strncpy(json_buff,ptr_gwd->node_val,JSON_BUFF_LEN); if(newlisp_process_json!=NULL) { newlisp_process_json(); } } #endif // simulate response wilddog_debug_printnode(p_snapshot); printf("\n"); fflush(stdout); wfree(ptr_gwd->node_val); return; }
STATIC int test_buildtreeFunc(void) { int m = 0; u8 url[strlen(TEST_URL)+20]; Wilddog_Node_T *p_head = NULL; //Wilddog_Node_T *p1 = NULL, *p2 = NULL, *p3 = NULL; Wilddog_Node_T *L1[2]; Wilddog_Node_T *L2[4]; Wilddog_Node_T *L3[8]; Wilddog_Node_T *L4[16]; Wilddog_Node_T *L5[32]; Wilddog_Node_T *L6[64]; Wilddog_Node_T *L7[128]; memset(key,0,20); p_head = wilddog_node_createObject(NULL); for(m = 0; m < 2; m++) { snprintf((char*)key, 20 , "%s%d", "L1",m); L1[m] = wilddog_node_createUString( key,(u8*)"L1L"); } for(m = 0; m < 4; m++) { snprintf((char*)key, 20 , "%s%d", "L2",m); L2[m] = wilddog_node_createUString( key,(u8*)"L2L"); } for(m = 0; m < 8; m++) { snprintf((char*)key, 20 , "%s%d", "L3",m); L3[m] = wilddog_node_createUString( key,(u8*)"L3L"); } for(m = 0; m < 16; m++) { snprintf((char*)key, 20 , "%s%d", "L4",m%10); L4[m] = wilddog_node_createUString( key,(u8*)"L4L"); } for(m = 0; m < 32; m++) { snprintf((char*)key, 20 , "%s%d", "L5",m%10); L5[m] = wilddog_node_createUString( key,(u8*)"L5L"); } for(m = 0; m < 64; m++) { snprintf((char*)key, 20 , "%s%d", "L6",m%10); L6[m] = wilddog_node_createUString( key,(u8*)"L6L"); } for(m = 0; m < 128; m++) { snprintf((char*)key, 20 , "%s%d", "L7",m%10); L7[m] = wilddog_node_createUString( key,(u8*)"L7L"); } for(m = 0; m < 2; m++) { wilddog_node_addChild(p_head, L1[m]); } for(m=0; m < 4; m++) { wilddog_node_addChild(L1[m/2], L2[m]); } for(m=0; m < 8; m++) { wilddog_node_addChild(L2[m/2], L3[m]); } for(m=0; m < 16; m++) { wilddog_node_addChild(L3[m/2], L4[m]); } for(m=0; m < 32; m++) { wilddog_node_addChild(L4[m/2], L5[m]); } for(m=0; m < 64; m++) { wilddog_node_addChild(L5[m/2], L6[m]); } for(m=0; m < 128; m++) { wilddog_node_addChild(L6[m/2], L7[m]); } /*3*/ isFinished = FALSE; memset((void*)url,0,sizeof(url)); sprintf((char*)url,"%s%s",TEST_URL,TEST_TREE_T_127); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { wilddog_debug("new wilddog error"); wilddog_node_delete(p_head); return -1; } wilddog_setValue(wilddog,L5[0],test_onSetFunc,(void*)TEST_TREE_T_127); //wilddog_node_delete(p_head); while(1) { if(TRUE == isFinished) { printf("\t set success! \n"); break; } wilddog_trySync(); } wilddog_destroy(&wilddog); /*4*/ if(TEST_TREE_ITEMS < 2) { wilddog_node_delete(p_head); return 0; } isFinished = FALSE; memset((void*)url,0,sizeof(url)); sprintf((char*)url,"%s%s",TEST_URL,TEST_TREE_T_256); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { wilddog_debug("new wilddog error"); wilddog_node_delete(p_head); return -1; } wilddog_setValue(wilddog,L4[0],test_onSetFunc,(void*)TEST_TREE_T_256); //wilddog_node_delete(p_head); while(1) { if(TRUE == isFinished) { printf("\t set success! \n"); break; } wilddog_trySync(); } wilddog_destroy(&wilddog); /*5*/ if(TEST_TREE_ITEMS < 3) { wilddog_node_delete(p_head); return 0; } isFinished = FALSE; memset((void*)url,0,sizeof(url)); sprintf((char*)url,"%s%s",TEST_URL,TEST_TREE_T_576); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { wilddog_debug("new wilddog error"); wilddog_node_delete(p_head); return -1; } wilddog_setValue(wilddog,L3[0],test_onSetFunc,(void*)TEST_TREE_T_576); //wilddog_node_delete(p_head); while(1) { if(TRUE == isFinished) { printf("\t set success! \n"); break; } wilddog_trySync(); } wilddog_destroy(&wilddog); /*6*/ if(TEST_TREE_ITEMS < 4) { wilddog_node_delete(p_head); return 0; } isFinished = FALSE; memset((void*)url,0,sizeof(url)); sprintf((char*)url,"%s%s",TEST_URL,TEST_TREE_T_810); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { wilddog_debug("new wilddog error"); wilddog_node_delete(p_head); return -1; } wilddog_setValue(wilddog,L2[0],test_onSetFunc,(void*)TEST_TREE_T_810); //wilddog_node_delete(p_head); while(1) { if(TRUE == isFinished) { printf("\t set success! \n"); break; } wilddog_trySync(); } wilddog_destroy(&wilddog); /*7*/ if(TEST_TREE_ITEMS < 5) { wilddog_node_delete(p_head); return 0; } isFinished = FALSE; memset((void*)url,0,sizeof(url)); sprintf((char*)url,"%s%s",TEST_URL,TEST_TREE_T_1044); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { wilddog_debug("new wilddog error"); wilddog_node_delete(p_head); return -1; } wilddog_setValue(wilddog,L1[0],test_onSetFunc,(void*)TEST_TREE_T_1044); //wilddog_node_delete(p_head); while(1) { if(TRUE == isFinished) { printf("\t set success! \n"); break; } wilddog_trySync(); } wilddog_destroy(&wilddog); /*8*/ if(TEST_TREE_ITEMS < 6) { wilddog_node_delete(p_head); return 0; } isFinished = FALSE; memset((void*)url,0,sizeof(url)); sprintf((char*)url,"%s%s",TEST_URL,TEST_TREE_T_1280); wilddog = wilddog_initWithUrl(url); if(0 == wilddog) { wilddog_debug("new wilddog error"); return -1; } wilddog_setValue(wilddog,p_head,test_onSetFunc,(void*)TEST_TREE_T_1280); wilddog_node_delete(p_head); while(1) { if(TRUE == isFinished) { printf("\t set success! \n"); break; } wilddog_trySync(); } wilddog_destroy(&wilddog); if(l_res < 0) printf("build tree error !!\n"); else printf("\n\ttest_buildtree finished\n"); return l_res; }
int main(int argc, char **argv) { char url[1024]; char value[1024]; char keys[256]; char host[512]; char authData[512]; BOOL authFlag = FALSE; memset(url,0,sizeof(url)); memset(value,0,sizeof(value)); memset(keys,0,sizeof(keys)); memset(host,0,sizeof(host)); memset(authData,0,sizeof(authData)); int type = 0; int opt,i,res = 0,cnt=0,cntmax=0; int option_index = 0; BOOL isFinish = FALSE,authFinish; Wilddog_T wilddog = 0; Wilddog_Node_T * p_node = NULL,*p_head = NULL; static struct option long_options[] = { {"auth", required_argument, 0, 0 }, {"value", required_argument, 0, 0 }, {"key", required_argument, 0, 0 }, {0, 0, 0, 0 } }; while((opt=getopt_long(argc,argv,"hl:",long_options,&option_index)) != -1) { switch (opt) { case 0: //printf("option %s", long_options[option_index].name); if (optarg) { if(strcmp(long_options[option_index].name,"key")==0) memcpy(keys, optarg,strlen(optarg)); if(strcmp(long_options[option_index].name,"value")==0) memcpy(value, optarg,strlen(optarg)); if(strcmp(long_options[option_index].name,"auth")==0) { authFlag = TRUE; memcpy(authData, optarg,strlen(optarg)); } } break; case 'h': fprintf(stderr, \ "Usage: %s setAuth|getValue|setValue|push|removeValue|addObser\n" "\t|disSetValue|disPush|disRemove|cacelDis|offLine|onLine\n" "\tver -l coap://<your appid>.wilddogio.com/ [ --auth=<auth data> " "--key=<key> --value=<value>]\n", argv[0]); return 0; case 'l': strcpy(url, (const char*)optarg); getHostFromAppid(host,url); sprintf(&host[strlen(host)],".wilddogio.com"); break; default: /* '?' */ fprintf(stderr, \ "Usage: %s setAuth|getValue|setValue|push|removeValue|addObser\n" "\t|disSetValue|disPush|disRemove|cacelDis|offLine|onLine\n" "\tver -l coap://<your appid>.wilddogio.com/ [ --auth=<auth data> " "--key=<key> --value=<value>]\n", argv[0]); return 0; } } for (i = 0; optind < argc; i++, optind++) { if(i == 0) { if(strcmp(argv[optind],"getValue")==0) { type= TEST_CMD_GET; cntmax = 0; } else if(strcmp(argv[optind],"setValue")==0) { type= TEST_CMD_SET; cntmax = 0; } else if(strcmp(argv[optind],"push")==0) { type=TEST_CMD_PUSH; cntmax = 0; } else if(strcmp(argv[optind],"removeValue")==0) { type=TEST_CMD_DELE; cnt =0; } else if(strcmp(argv[optind],"addObserver")==0) { type= TEST_CMD_ON; cntmax = 10; } else if(strcmp(argv[optind],"setAuth")==0) { type= TEST_CMD_SETAUTH; cntmax = 0; } else if(strcmp(argv[optind],"disSetValue")==0) { type= TEST_CMD_ONDISSET; cntmax = 0; } else if(strcmp(argv[optind],"disPush")==0) { type= TEST_CMD_ONDISPUSH; cntmax = 0; } else if(strcmp(argv[optind],"disRemove")==0) { type= TEST_CMD_ONDISREMOVE; cntmax = 0; } else if(strcmp(argv[optind],"cacelDis")==0) { type= TEST_CMD_CANCELDIS; cntmax = 0; } else if(strcmp(argv[optind],"offLine")==0) { type= TEST_CMD_OFFLINE; cntmax = 0; } else if(strcmp(argv[optind],"onLine")==0) { type= TEST_CMD_ONLINE; cntmax = 0; } } } if( !type) { printf("Usage: %s setAuth|getValue|setValue|push|removeValue|addObser\n" "\t|disSetValue|disPush|disRemove|cacelDis|offLine|onLine\n" "\tver -l coap://<your appid>.wilddogio.com/ [ --auth=<auth data> " "--key=<key> --value=<value>]\n", argv[0]); return 0; } /*Create an node which type is an object*/ p_head = wilddog_node_createObject(NULL); /*Create an node which type is UTF-8 Sring*/ p_node = wilddog_node_createUString((Wilddog_Str_T *)keys, \ (Wilddog_Str_T *)value); /*Add p_node to p_head, then p_node is the p_head's child node*/ wilddog_node_addChild(p_head, p_node); /*Init a wilddog client*/ wilddog = wilddog_initWithUrl((Wilddog_Str_T *)url); if(authFlag == TRUE) res = wilddog_auth((u8*)host,(u8*)authData, \ strlen((const char *)authData), auth_callback,(void*)&authFinish); switch(type) { case TEST_CMD_GET: /*Send the query method*/ res = wilddog_getValue(wilddog, (onQueryFunc)getValue_callback, \ (void*)&isFinish); break; case TEST_CMD_SET: /*Send the set method*/ res = wilddog_setValue(wilddog,p_head,setValue_callback, \ (void*)&isFinish); break; case TEST_CMD_PUSH: /*Send the push method*/ res = wilddog_push(wilddog, p_head, push_callback, \ (void *)&isFinish); break; case TEST_CMD_DELE: /*Send the remove method*/ res = wilddog_removeValue(wilddog, removeValue_callback, \ (void*)&isFinish); break; case TEST_CMD_ON: /*Observe on*/ res = wilddog_addObserver(wilddog, WD_ET_VALUECHANGE,\ addObserver_callback, \ (void*)&isFinish); break; case TEST_CMD_SETAUTH: wilddog_debug("TEST_CMD_SETAUTH token = %s",value); res = wilddog_auth((u8*)host,(u8*)value, \ strlen((const char *)value), auth_callback,(void*)&isFinish); case TEST_CMD_ONDISSET: /*Send the remove method*/ res = wilddog_onDisconnectSetValue(wilddog,p_head,onDis_callback, \ (void*)&isFinish); break; case TEST_CMD_ONDISPUSH: /*Send the remove method*/ res = wilddog_onDisconnectPush(wilddog,p_head,onDis_callback, \ (void*)&isFinish); break; case TEST_CMD_ONDISREMOVE: /*Send the remove method*/ res = wilddog_onDisconnectRemoveValue(wilddog, onDis_callback, \ (void*)&isFinish); break; case TEST_CMD_CANCELDIS: /*Send the remove method*/ res = wilddog_cancelDisconnectOperations(wilddog, onDis_callback, \ (void*)&isFinish); break; case TEST_CMD_OFFLINE: /*Send the remove method*/ res = wilddog_goOffline(); break; case TEST_CMD_ONLINE: /*Send the remove method*/ res = wilddog_goOnline(); break; } /*Delete the node*/ wilddog_node_delete(p_head); while(1) { if(TRUE == isFinish) { if(type == TEST_CMD_ON) wilddog_debug("get new data %d times! after %d times, will " \ "remove Observer.", cnt, cntmax); cnt++; isFinish = FALSE; if(cnt > cntmax)/*force break when received new data.*/ { if(type == TEST_CMD_ON) { wilddog_debug("off the data!"); /*Observe off*/ wilddog_removeObserver(wilddog, WD_ET_VALUECHANGE); } break; } } /* * Handle the event and callback function, it must be called in a * special frequency */ wilddog_trySync(); } /*Destroy the wilddog clent and release the memory*/ wilddog_destroy(&wilddog); return res; }
int main(int argc, char **argv) { char url[1024]; char cmd[256]; char data[32]; char verbose[32]; char quote[32]; char authvalue[256]; BOOL isFinished = FALSE; Wilddog_T wilddog = 0; int opt; int option_index = 0; WATCH_CTX watch_ctx; char *host = NULL; memset(url,0,sizeof(url)); memset(cmd,0,sizeof(cmd)); memset(data,0,sizeof(data)); memcpy(data, "yes",strlen("yes")); memset(verbose,0,sizeof(verbose)); memcpy(verbose, "no",strlen("no")); memset(quote,0,sizeof(quote)); memcpy(quote, "yes",strlen("yes")); memset(authvalue,0,sizeof(authvalue)); static struct option long_options[] = { {"ignore-origin-data", required_argument, 0, 0 }, {"verbose", required_argument, 0, 0}, {"ignore-leaf-quote", required_argument, 0, 0}, {"version", no_argument, 0, 0}, {"authvalue", required_argument, 0, 0}, {0, 0, 0, 0 } }; while ((opt = getopt_long(argc, argv, "ovsh",long_options, &option_index)) != -1) { switch (opt) { case 0: //printf("option!!! %s\n", long_options[option_index].name); if (optarg) { if(strcmp(long_options[option_index].name,"ignore-origin-data")==0) memcpy(data, optarg,strlen(optarg)); if(strcmp(long_options[option_index].name,"verbose")==0) memcpy(verbose, optarg,strlen(optarg)); if(strcmp(long_options[option_index].name,"ignore-leaf-quote")==0) memcpy(quote, optarg,strlen(optarg)); if(strcmp(long_options[option_index].name,"authvalue")==0) memcpy(authvalue, optarg,strlen(optarg)); } if(strcmp(long_options[option_index].name,"version")==0) { printf("liveshell Version: %s\n", LIVESHELL_VERSION); return 0; } break; case 'o': memcpy(data, "no",strlen("no")); break; case 'v': memcpy(verbose, "yes",strlen("yes")); break; case 's': memcpy(quote, "no",strlen("no")); break; case 'h': fprintf(stderr, "Usage: %s [option] [--authvalue= your auth data] <your wilddog url> <your callback command> \n", argv[0]); return 0; default: /* '?' */ fprintf(stderr, "Usage: %s [option] [--authvalue= your auth data] <your wilddog url> <your callback command> \n", argv[0]); return 0; } } if( argc < 3 ) { printf("Usage: %s [option] [--authvalue= your auth data] <your wilddog url> <your callback command> \n", argv[0]); return 0; } memcpy(cmd, argv[argc-1], strlen(argv[argc-1])); memcpy(url, argv[argc-2], strlen(argv[argc-2])); wilddog = wilddog_initWithUrl((Wilddog_Str_T *)url); if(0 == wilddog) { wilddog_debug("new wilddog failed!"); return 0; } if(strlen(authvalue) != 0) { host = getHostFromUrl(url); //printf("host:%s\n", host); //printf("authvalue:%s\n", authvalue); wilddog_auth((u8*)host,(u8*)authvalue,strlen((const char *)authvalue),auth_callback,(void*)&isFinished); } isFinished = FALSE; watch_ctx.cmd = cmd; watch_ctx.data = data; watch_ctx.verbose = verbose; watch_ctx.quote = quote; watch_ctx.isFinished = &isFinished; wilddog_addObserver(wilddog, WD_ET_VALUECHANGE, observer_callback, (void*)&watch_ctx); while(1) { if(TRUE == *(watch_ctx.isFinished)) { //wilddog_debug("get new data %d times!", count++); *(watch_ctx.isFinished) = FALSE; /*do not break*/ //break; } wilddog_trySync(); } wfree(host); wilddog_destroy(&wilddog); return 0; }
STATIC void observer_callback ( const Wilddog_Node_T* p_snapshot, void* arg, Wilddog_Return_T err ) { int ret = 0; char cmd[1024]; static int times=0; pid_t pid; char * pstr = NULL; char * pleaf = NULL; Wilddog_Node_T *p_clone = NULL; Wilddog_Str_T *p_key = NULL; char *d = " "; char *ps = NULL; char *args[0]; int i = 0,j = 1; memset(cmd,0,1024); *((*(WATCH_CTX*)arg).isFinished)= TRUE; if(err < WILDDOG_HTTP_OK || err >= WILDDOG_HTTP_NOT_MODIFIED) { wilddog_debug("addObserver failed!"); return; } if(strncmp("yes", (*(WATCH_CTX*)arg).data, strlen("yes")) == 0 && times == 0) { times++; return; } pid = fork(); if(pid == -1) perror("fork"); if(!pid) { p_clone = wilddog_node_clone(p_snapshot); p_key = p_clone->p_wn_key; p_clone->p_wn_key = NULL; pstr = (char *)wilddog_debug_n2jsonString(p_clone); fflush(stdout); /*Handle cmd's arg, add to arg table. Such as "ls -l", "-l" is an arg*/ if((strncmp("no", (*(WATCH_CTX*)arg).quote, strlen("no")) != 0) && p_clone->p_wn_child == NULL && p_clone->d_wn_type == WILDDOG_NODE_TYPE_UTF8STRING) { /*If node is leaf and value is string, seperate to args by space*/ pleaf = wmalloc(strlen(pstr)-1); memcpy(pleaf, pstr+1, strlen(pstr)-2); *(pleaf+strlen(pleaf)) = '\0'; args[0] = strtok( (char *)((*(WATCH_CTX*)arg).cmd), d); while(ps = strtok(NULL,d)) { args[j++] = ps; } args[j++] = strtok(pleaf, d); while(ps = strtok(NULL,d)) { args[j++] = ps; } args[j] = NULL; } else { args[0] = strtok( (char *)((*(WATCH_CTX*)arg).cmd), d); while(ps = strtok(NULL,d)) { args[j++] = ps; } args[j] = wmalloc(strlen(pstr)+1); memcpy(args[j], pstr, strlen(pstr)); args[++j] = NULL; } if(strncmp("yes", (*(WATCH_CTX*)arg).verbose, strlen("yes")) == 0) { printf("exec this cmd and param: "); for(i = 0; i < j; i++) { printf("%s ", args[i]); fflush(stdout); } printf("\n\n"); fflush(stdout); } ret = execvp((char *)((*(WATCH_CTX*)arg).cmd), args); wfree(pstr); wfree(pleaf); for( i = 0; i < j+1; i++) wfree(args[i]); p_clone->p_wn_key = p_key; wilddog_node_delete(p_clone); if(ret == -1) { perror("execv"); exit(EXIT_FAILURE); } } return; }
int demo(char* url, int* isUnConnected) { BOOL isFinish = FALSE; Wilddog_T wilddog = 0; Wilddog_Node_T * p_node = NULL, *p_head = NULL, *p_node_query = NULL; p_head = wilddog_node_createObject(NULL); /* create a new child to "wilddog" , key is "1", value is "1" */ p_node = wilddog_node_createUString((Wilddog_Str_T*)"led1",(Wilddog_Str_T*)"1"); /*p_node was p_head's child */ wilddog_node_addChild(p_head, p_node); /*creat new a client*/ wilddog = wilddog_initWithUrl((Wilddog_Str_T*)url); if(0 == wilddog) { wilddog_debug("new wilddog error"); return 0; } printf("\n\t seting led1=1 to %s\n",url); /* expect <appId>.wilddogio.com/ has a new node "1" * test_onSetFunc : handle recv data while response * */ wilddog_setValue(wilddog,p_head,test_onSetFunc,(void*)&isFinish); /* dele node */ wilddog_node_delete(p_head); while(1) { if(*isUnConnected) { wilddog_debug("wlan off!"); break; } if(TRUE == isFinish) { wilddog_debug("\tset led1=1 success!"); break; } /*retransmit¡¢ received and handle response * */ wilddog_trySync(); } printf("\n\t send query to %s \n",url); /* send query */ wilddog_getValue(wilddog, test_onQueryFunc, (void*)(&p_node_query)); while(1) { if(p_node_query) { printf("\t get %s data: \n",url); /* printf recv node as json */ wilddog_debug_printnode(p_node_query); /* free p_node_query */ wilddog_node_delete(p_node_query); printf("\n"); break; } wilddog_trySync(); } /* free wilddog*/ wilddog_destroy(&wilddog); return 0; }
int test(char *uid) { char url[1024]; char en_key = 0; BOOL isFinished = FALSE; Wilddog_T wilddog; Wilddog_Handle_T s_handle; Wilddog_Node_T *p_head = NULL, *p_node = NULL/*, *p_snapshot = NULL*/; u8 value1[5] = {246,12,0,0,6}; /*u8 value2[4] = {23,67,98,1};*/ wFloat f = 2.3; Wilddog_Node_T *root; Wilddog_Node_T *L1c1,*L1c2; Wilddog_Node_T *L2c1,*L2c2,*L2c3; Wilddog_Node_T *L3c1,*L3c2,*L3c3,*L3c4,*L3c5; Wilddog_Node_T *L4c1,*L4c2,*L4c3,*L4c4,*L4c5; int count = 0; sprintf(url,"%s%s%s",TEST_URL_HEAD,uid,TEST_URL_END); memset(&s_handle, 0, sizeof(s_handle)); s_handle.isFinished = FALSE; printf("*******************************************\n"); printf("First Step: Build the data tree \n"); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif root = wilddog_node_createNum((Wilddog_Str_T *)"root",9999); L1c1 = wilddog_node_createFalse((Wilddog_Str_T *)"L1c1"); L1c2 = wilddog_node_createTrue((Wilddog_Str_T *)"L1c2"); L2c1 = wilddog_node_createNum((Wilddog_Str_T *)"L2c1",-10000); L2c2 = wilddog_node_createFloat((Wilddog_Str_T *)"L2c2",f); L2c3 = wilddog_node_createTrue((Wilddog_Str_T *)"L2c3"); //true L3c1 = wilddog_node_createBString((Wilddog_Str_T *)"L3c1",value1,sizeof(value1)/sizeof(u8)); //BString L3c2 = wilddog_node_createTrue((Wilddog_Str_T *)"L3c2"); L3c3 = wilddog_node_createTrue((Wilddog_Str_T *)"L3c3"); L3c4 = wilddog_node_createNull((Wilddog_Str_T *)"L3c4"); //NULL L3c5 = wilddog_node_createTrue((Wilddog_Str_T *)"L3c5"); L4c1 = wilddog_node_createNum((Wilddog_Str_T *)"L4c1",875);// +Num L4c2 = wilddog_node_createNum((Wilddog_Str_T *)"L4c2",-5693); // -Num L4c3 = wilddog_node_createFloat((Wilddog_Str_T *)"L4c3",f); //float L4c4 = wilddog_node_createFalse((Wilddog_Str_T *)"L4c4"); //false L4c5 = wilddog_node_createUString((Wilddog_Str_T *)"L4c5",(Wilddog_Str_T *)"string"); //UString if(WILDDOG_ERR_NOERR != wilddog_node_addChild(root,L1c1)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(root,L1c2)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L1c1,L2c1)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L1c1,L2c2)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L1c2,L2c3)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c1,L3c1)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c1,L3c2)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c2,L3c3)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c2,L3c4)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L2c2,L3c5)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c2,L4c1)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c3,L4c2)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c3,L4c3)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c5,L4c4)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } if(WILDDOG_ERR_NOERR != wilddog_node_addChild(L3c5,L4c5)) { wilddog_debug_level(WD_DEBUG_ERROR,"node add error"); } printf("*******************************************\n"); printf("The data is built as below:\n"); wilddog_debug_printnode(root); printf("\n"); printf("*******************************************\n"); printf("\n\n"); /* printf("*******************************************\n"); printf("Second Step: Use the Node API to change the data tree\n"); printf("Change the L1c1 node's key from \"L1c1\" to \"L1c1New\" \n"); wilddog_node_setKey(L1c1,(Wilddog_Str_T *)"L1c1New"); printf("Change the L3c1 node's value from Bytestring \"{0xf6,0x0c,0x00,0x00,0x06}\" to Bytestring \"{0x17,0x43,0x62,0x01}\"\n "); wilddog_node_setValue(L3c1,value2,sizeof(value2)/sizeof(u8)); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif printf("*******************************************\n"); printf("The data tree had changed as below:\n"); wilddog_debug_printnode(root); printf("\n"); printf("*******************************************\n"); printf("\n\n"); */ /* printf("*******************************************\n"); printf("Clone the data tree from L2c2 node\n"); printf("Print the L2c2 data tree\n"); p_snapshot = wilddog_node_clone(L2c2); wilddog_debug_printnode(p_snapshot); wilddog_node_delete(p_snapshot); printf("\n"); printf("*******************************************\n"); printf("\n\n"); */ /*************************************************************/ wilddog = wilddog_initWithUrl((Wilddog_Str_T *)url); printf("*******************************************\n"); printf("Third step: Remove the %s's data\n",uid); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif wilddog_removeValue(wilddog, test_onDeleteFunc, (void*)&isFinished); while(1) { if(TRUE == isFinished) { wilddog_debug("remove success!"); break; } wilddog_trySync(); } isFinished = FALSE; /*************************************************************/ printf("*******************************************\n"); printf("It has removed all data in %s!\n",uid); printf("Please check the data on %s page\n",url); printf("*******************************************\n"); printf("\n\n"); printf("*******************************************\n"); printf("Fourth step: Set the root node to the %s's data tree\n",uid); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif wilddog_setValue(wilddog,root,test_onSetFunc,(void*)&isFinished); wilddog_node_delete(root); while(1) { if(TRUE == isFinished) { wilddog_debug("set success!"); break; } wilddog_trySync(); } isFinished = FALSE; printf("*******************************************\n"); printf("It has set the data in %s!\n",uid); printf("Please check the data tree on %s page\n",url); printf("*******************************************\n"); printf("\n\n"); /*****************************************************************/ printf("*******************************************\n"); printf("Fifth step: Get the %s's data\n",uid); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif s_handle.p_node = NULL; wilddog_getValue(wilddog, test_onQueryFunc, (void*)(&s_handle)); while(1) { if(s_handle.isFinished) { if(s_handle.p_node) { wilddog_debug("print node:"); wilddog_debug_printnode(s_handle.p_node); wilddog_node_delete(s_handle.p_node); s_handle.p_node= NULL; printf("\n"); break; } } wilddog_trySync(); } isFinished = FALSE; printf("*******************************************\n"); printf("It has get the data in %s!\n",uid); printf("Please check the data tree!\n"); printf("*******************************************\n"); printf("\n\n"); /*****************************************************************/ p_head = wilddog_node_createObject((Wilddog_Str_T *)"3"); p_node = wilddog_node_createNum((Wilddog_Str_T *)"2",1234); wilddog_node_addChild(p_head, p_node); printf("*******************************************\n"); printf("Sixth step: Build a node as \"{\"2\":1234}\"\n"); printf("Push the new node to the %s's data tree's root node\n",uid); printf("Please press enter key to continue!\n"); printf("*******************************************\n"); printf("\n\n"); #ifndef WILDDOG_PORT_TYPE_WICED while(1) { en_key= getchar(); if(en_key == '\n') break; } en_key = 0; #endif wilddog_push(wilddog, p_head, test_onPushFunc, (void *)&isFinished); wilddog_node_delete(p_head); while(1) { if(isFinished) { wilddog_debug("push success!"); break; } wilddog_trySync(); } printf("*******************************************\n"); printf("It has pushed the data in %s!\n",uid); printf("Please check the data tree on %s page\n",url); printf("\{\"2\":1234}\" will have a parent which have a long number\n");