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;
}
Exemple #4
0
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;
}
Exemple #6
0
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;
}
Exemple #8
0
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;
}
Exemple #11
0
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;
}
Exemple #13
0
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;
}
Exemple #14
0
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;
}
Exemple #16
0
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;
}
Exemple #17
0
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();
}
Exemple #19
0
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;
}
Exemple #21
0
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;
}
Exemple #22
0
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;
}
Exemple #23
0
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;

}
Exemple #24
0
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;
}
Exemple #25
0
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;
}
Exemple #26
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");