int main(int argc, char **argv) 
{
    BOOL aisFinish = FALSE,bisFinish = FALSE;
    Wilddog_T wilddog_a = 0;
	Wilddog_T wilddog_b = 0;

	if( argc != 3 )
	{
		printf("input : \t ./test_mutiple_observer url1/path1 url2/path2 \n");
		return -1;
	}
	wilddog_a = wilddog_initWithUrl((Wilddog_Str_T*)argv[1]);
	wilddog_b = wilddog_initWithUrl((Wilddog_Str_T*)argv[2]);
	wilddog_addObserver(wilddog_a, WD_ET_VALUECHANGE,\
                                      addObserver_callback_a, \
                                      (void*)&aisFinish);	
	
    wilddog_addObserver(wilddog_b, WD_ET_VALUECHANGE,\
                                      addObserver_callback_b, \
                                      (void*)&bisFinish);
    while(1)
    {

        wilddog_trySync();
		
    }

    wilddog_destroy(&wilddog_a);
    wilddog_destroy(&wilddog_b);
	

    return 0;
}
Esempio n. 2
0
STATIC	void stab_settest_dataInit(u8 idx)
{
	int i;
    //char temp_url[strlen(TEST_URL)+20];
    char temp_url[256];

    memset(temp_url,0,sizeof(temp_url));
	for(i=0;i<10;i++)
	{
		stab_setdata[i].key[0] = 'K';
		stab_setdata[i].data[0] = 'D';
		
		stab_setdata[i].key[1] = 0x30+i; 		
		stab_setdata[i].data[1] = 0x30+idx; 

		stab_setdata[i].data[2] = 0x30+i;
		sprintf((char*)temp_url,"%s/%s",TEST_URL,stab_setdata[i].key);
 		if(stab_setdata[i].client)
			wilddog_destroy(&(stab_setdata[i].client));
		stab_setdata[i].client = wilddog_initWithUrl((Wilddog_Str_T*)temp_url);
		if(stab_setdata[i].p_node)
		{
			wilddog_node_delete(stab_setdata[i].p_node);
			stab_setdata[i].p_node = NULL;
		}
		stab_setdata[i].p_node = wilddog_node_createUString(
									(Wilddog_Str_T *)stab_setdata[i].key,\
									(Wilddog_Str_T *)stab_setdata[i].data);
	}

}
Esempio n. 3
0
STATIC void stab_settest_dataDeInit(void)
{
	int i;
	for(i=0;i<10;i++)
	{
		if(stab_setdata[i].p_node)
		{
 			wilddog_node_delete(stab_setdata[i].p_node);
 			stab_setdata[i].p_node = NULL;
		}
		if(stab_setdata[i].client)
		{
			
 			wilddog_destroy(&stab_setdata[i].client);
 		}
 		stab_setdata[i].setfault = 0;
	}
}
Esempio n. 4
0
void ramtest_handle( u8 tree_num, u8 request_num)
{
	u8 m = 0;
	Wilddog_T wilddog = 0;
	
	u8 url[64]={0};

	ramtest_init(tree_num,request_num);
    sprintf((char*)url, "coaps://c_test.wilddogio.com/ramtest/tree_%d", tree2len[tree_num]);
	
	wilddog = wilddog_initWithUrl(url);
		
	if(0 == wilddog)
	{
		return;
	}
	count = 0;
	for(m=0; m < request_num; m++)
	{
		int res = wilddog_getValue(wilddog, test_onQueryFunc, NULL);
		if(0 == res)
			count++;
		else
			d_ramtest.d_sendfalt++;
	}
	ramtest_caculate_requestQueueRam();
	while(1)
	{
		if(count == 0)
		{
			
			ramtest_printf(&d_ramtest);
			break;
		}
		ramtest_getAveragesize();
		wilddog_trySync();
	}
	wilddog_destroy(&wilddog);
	return;
Esempio n. 5
0
int stab_oneCrcuRequest(void) 
{
	int res = 0;
	BOOL otherFinish = FALSE,onFinish = FALSE;
	BOOL *p_finish = &onFinish;
    Wilddog_T client = 0;
    STABTEST_CMD_TYPE cmd = STABTEST_CMD_ON;

	/* mark star time*/
	stab_set_runtime();
    /*Init a wilddog client*/
    client = wilddog_initWithUrl((Wilddog_Str_T *)TEST_URL);
	
	stab_get_requestRes(stabtest_request(cmd,client,p_finish));

    while(1)
    {
        if(TRUE == *p_finish)
        {
        	if(STABTEST_ONREQUEST(cmd))
        		p_finish = &otherFinish;

        	onFinish = FALSE;
        	otherFinish = FALSE;
			STABTEST_NEXTREQUEST(cmd);
			stab_get_requestRes(stabtest_request(cmd,client,p_finish));
			
			if(STABTEST_OFFREQUEST(cmd))
			{
				break;
			}	
        }
        stab_trysync();
    }
    /*Destroy the wilddog clent and release the memory*/
    res = wilddog_destroy(&client);

    return res;
}
int main(void)
{

    char host1[TESTURL_NUM],host2[TESTURL_NUM],host3[TESTURL_NUM];

    Wilddog_T client1= 0,client2 = 0,client3 = 0;

    memset(host1,0,TESTURL_NUM);
    memset(host2,0,TESTURL_NUM);
    memset(host3,0,TESTURL_NUM);


    printf(" @@mutiple test\n");

    printf("APPID : %s \n",TEST_URL);
    printf("APPID2 : %s \n",TEST_URL2);
    printf("APPID3 : %s \n",TEST_URL3);


    test_gethost(host1,TEST_URL);
    test_gethost(host2,TEST_URL2);
    test_gethost(host3,TEST_URL3);


    multipleClient[0].p_host = host1;
    multipleClient[1].p_host = host2;
    multipleClient[2].p_host = host3;

    client1 = wilddog_initWithUrl((Wilddog_Str_T *)TEST_URL);
    client2 = wilddog_initWithUrl((Wilddog_Str_T *)TEST_URL2);
    client3 = wilddog_initWithUrl((Wilddog_Str_T *)TEST_URL3);
    /* set */

    printf("test set \n");
    multipletest_request(MULTIPLETEST_CMD_SET,client1,&multipleClient[0]);
    multipletest_request(MULTIPLETEST_CMD_SET,client2,&multipleClient[1]);
    multipletest_request(MULTIPLETEST_CMD_SET,client3,&multipleClient[2]);

    multiple_trysync();
    printf("test get \n");
    /*get */
    multipletest_request(MULTIPLETEST_CMD_GET,client1,&multipleClient[0]);
    multipletest_request(MULTIPLETEST_CMD_GET,client2,&multipleClient[1]);
    multipletest_request(MULTIPLETEST_CMD_GET,client3,&multipleClient[2]);
    multiple_trysync();

    printf("test observer \n");
    //while(1);
    /* ON */
    multipletest_request(MULTIPLETEST_CMD_ON,client1,&multipleClient[0]);
    multipletest_request(MULTIPLETEST_CMD_ON,client2,&multipleClient[1]);
    multipletest_request(MULTIPLETEST_CMD_ON,client3,&multipleClient[2]);
    multiple_trysync();
    /*PUSH */

    printf("test PUSH \n");
    multipletest_request(MULTIPLETEST_CMD_PUSH,client1,&multipleClient[0]);
    multipletest_request(MULTIPLETEST_CMD_PUSH,client2,&multipleClient[1]);
    multipletest_request(MULTIPLETEST_CMD_PUSH,client3,&multipleClient[2]);
    multiple_trysync();

    /*DELETE */

    printf("test delete \n");
    multipletest_request(MULTIPLETEST_CMD_DELE,client1,&multipleClient[0]);
    multipletest_request(MULTIPLETEST_CMD_DELE,client2,&multipleClient[1]);
    multipletest_request(MULTIPLETEST_CMD_DELE,client3,&multipleClient[2]);
    multiple_trysync();

    /* OFF
    multipletest_request(MULTIPLETEST_CMD_ON,client1,&multipleClient[0]);
    multipletest_request(MULTIPLETEST_CMD_ON,client2,&multipleClient[1]);
    multipletest_request(MULTIPLETEST_CMD_ON,client3,&multipleClient[2]);
    multiple_trysync();
    */
    /* result printf */
    multiple_testResultPrint(&multipleClient[0]);
    multiple_testResultPrint(&multipleClient[1]);
    multiple_testResultPrint(&multipleClient[2]);


    /* destory*/
    wilddog_destroy(&client1);
    wilddog_destroy(&client2);
    wilddog_destroy(&client3);

    if( multiple_testResultReturn(&multipleClient[0]) == -1 ||
            multiple_testResultReturn(&multipleClient[1]) == -1 ||
            multiple_testResultReturn(&multipleClient[2]) == -1
      )
        return -1;
    else
        return 0;
}
Esempio n. 7
0
void WD_SYSTEM performtest_handle
	(
	u32 delay_tm,
	const u8 *p_url,
	u32 tree_num, 
	u8 request_num
	)
{
    u8 m = 0;
    Wilddog_T wilddog = 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;
    performtest_setSysState(SYS_AUTHRECV);
    performtest_timeReset();
    while(1)
    {
        wilddog_trySync();
        if(SYS_ISIN(SYS_APPLICATIONSENDING))
            break;
    }
    performtest_timeReset();
    for(m=0; m < request_num; m++)
    {
        performtest_timeReset();
        /*printf("g_performtest.d_tm_star = %ul\n", g_performtest.d_tm_star);*/
        int res = wilddog_getValue(wilddog, test_onQueryFunc, NULL);
        performtest_getSendTime();
        /*printf("g_performtest.d_tm_send = %ul\n", g_performtest.d_tm_send);*/
        if(0 == res)
            perform_count++;
        else
            g_performtest.d_send_fault++;
        /*printf("send =%d;res =%d \n",perform_count,res);*/
    }
    performtest_timeReset();
    performtest_setSysState(SYS_APPLICATIONRECV);
    while(1)
    {
        if(perform_count == 0)
        {
            //printf("break\n");
            performtest_printf(&g_performtest);
            break;
        }
#ifdef WILDDOG_PORT_TYPE_WICED
        wiced_rtos_delay_milliseconds(g_performtest.d_tm_trysync_delay);
#else
#if defined WILDDOG_PORT_TYPE_ESP
        os_delay_us(1000 * g_performtest.d_tm_trysync_delay);
#else
        usleep(g_performtest.d_tm_trysync_delay);
#endif
#endif
        wilddog_increaseTime(g_performtest.d_tm_trysync_delay);
        wilddog_trySync();
    }
    wilddog_destroy(&wilddog);
    return;
}
Esempio n. 8
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;

}
Esempio n. 9
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;
}
Esempio n. 10
0
Wilddog_Return_T wilddog_close( guu_is_wilddog_t*gwd)
{
	return wilddog_destroy(&gwd->wd);
}
Esempio n. 11
0
void performtest_handle( u32 delay_tm,u8 tree_num, u8 request_num)
{
	u8 m = 0;
	Wilddog_T wilddog = 0;
    u8 url[64]={0};
	
    sprintf((char*)url, "coaps://c_test.wilddogio.com/performtest/tree_%d", tree2len[tree_num]);
	
	performtest_init(delay_tm,tree_num,request_num);
	performtest_setSysState(SYS_HSK);

	wilddog = wilddog_initWithUrl(url);
		  
	if(0 == wilddog)
	{
		return;
	}
	perform_count = 0;
	performtest_setSysState(SYS_AUTHRECV);
	performtest_star_tm();
	while(1)
	{
		wilddog_trySync();
		if(SYS_ISIN(SYS_APPLICATIONSENDING))
			break;
	}
	performtest_star_tm();
	for(m=0; m < request_num; m++)
	{
		performtest_star_tm();
		/*printf("g_performtest.d_tm_star = %ul\n", g_performtest.d_tm_star);*/
		int res = wilddog_getValue(wilddog, test_onQueryFunc, NULL);
		performtest_tm_getSend();
		/*printf("g_performtest.d_tm_send = %ul\n", g_performtest.d_tm_send);*/
				if(0 == res)
			perform_count++;
		else
			g_performtest.d_send_fault++;
		/*printf("send =%d;res =%d \n",perform_count,res);*/
	}
	performtest_star_tm();
	performtest_setSysState(SYS_APPLICATIONRECV);
	while(1)
	{
		if(perform_count == 0)
		{
			//printf("break\n");
			performtest_printf(&g_performtest);
			break;
		}
#ifdef WILDDOG_PORT_TYPE_WICED
		wiced_rtos_delay_milliseconds(g_performtest.d_tm_trysync_delay);
#else 
		usleep(g_performtest.d_tm_trysync_delay);
#endif
		wilddog_increaseTime(g_performtest.d_tm_trysync_delay);
		wilddog_trySync();
	}
	wilddog_destroy(&wilddog);
	return;
}
Esempio n. 12
0
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;
}
Esempio n. 13
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;
}
int main(void)
{
	int i, j;
 
	Wilddog_T p_repo1_ref1 = 0, p_repo1_ref2 =0;
	Wilddog_T p_repo2_ref1 = 0, p_repo2_ref2 = 0,p_repo2_ref1_cpy = 0;
	Wilddog_T p_ref[6];
	Wilddog_T p_parent = 0, p_root = 0, p_child  = 0;

	for(j = 0; j < FUNC_NUM; j++)
	{
		memset(&test_results[j], 0, sizeof(struct test_reult_t));
	}
	test_results[0].name = "wilddog_getParent";
	test_results[1].name = "wilddog_getRoot";
	test_results[2].name = "wilddog_getChild";

	/*
	 *  test the url format
	 */
	for( i = 0; i < sizeof(test_url)/sizeof(char *); i++)
	{
		p_ref[i] = wilddog_initWithUrl((Wilddog_Str_T *)test_url[i]);	

		if(p_ref[i])
		{
			wilddog_debug_level(WD_DEBUG_LOG, "p_ref--  [%d] \n\n", i);
			wilddog_debug_printUrl(p_ref[i]);
			wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n");
		}
		else
		{
			wilddog_debug_level(WD_DEBUG_LOG, "------------------------\n");
			wilddog_debug_level(WD_DEBUG_LOG, "%s could not init\n\n", test_url[i]);
			wilddog_debug_level(WD_DEBUG_LOG, "------------------------\n");
			
			TEST_RESULT_PRINTF("test_all:wilddog_initWithUrl error",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR);
			return ABORT_ERR;
		}
	}

	wilddog_debug_level(WD_DEBUG_LOG, "\n\ndestroy the test url before\n\n");
	for( i = 0; i < sizeof(test_url)/sizeof(char *); i++)
	{
		wilddog_debug_level(WD_DEBUG_LOG, "destroy %d test url %lu\n", i, (long unsigned int)p_ref[i]);
		if(p_ref[i])
			wilddog_destroy(&(p_ref[i]));
	}
	wilddog_debug_level(WD_DEBUG_LOG, "\n\ndestroy the test url after\n\n");

	/*
	 *  test the multi repo and multi ref
	 *  test getparent getchild getroot
	 */
	p_repo1_ref1 = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid1.wilddogio.com/a1");
	p_repo1_ref2 = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid1.wilddogio.com/a1/b2");

	p_repo2_ref1 = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid2.wilddogio.com/c3");
	p_repo2_ref1_cpy = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid2.wilddogio.com/c3");
	p_repo2_ref2 = wilddog_initWithUrl((Wilddog_Str_T *)"coaps://appid2.wilddogio.com/c3/d4/e5");
	
	if(p_repo1_ref1)
	{
		wilddog_debug_level(WD_DEBUG_LOG, "repo1--ref1\n\n");
		wilddog_debug_printUrl(p_repo1_ref1);
		wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n");
	}

	if(p_repo1_ref2)
	{
		wilddog_debug_level(WD_DEBUG_LOG, "repo1--ref2\n\n");
		wilddog_debug_printUrl(p_repo1_ref2);
		wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n");
	}

	if(p_repo2_ref1)
	{
		wilddog_debug_level(WD_DEBUG_LOG, "repo2--ref1\n\n");
		wilddog_debug_printUrl(p_repo2_ref1);
		wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n");
	}
	if(p_repo2_ref1 != p_repo2_ref1_cpy)
	{
		TEST_RESULT_PRINTF( "test_all: new same url error ",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR);
		return ABORT_ERR;
	}
	if(p_repo2_ref2)
	{
		wilddog_debug_level(WD_DEBUG_LOG, "repo2--ref2\n\n");
		wilddog_debug_printUrl(p_repo2_ref2);
		wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n");
	}

	p_parent = wilddog_getParent(p_repo1_ref2);
	
	if(p_parent == p_repo1_ref1)
	{
		wilddog_debug_level(WD_DEBUG_LOG, "repo1--ref2--parent\n\n");
		wilddog_debug_printUrl(p_parent);
		test_results[0].result = TRUE;
		wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n");

	}
	else
	{
		wilddog_debug_level(WD_DEBUG_LOG, "could not get repo1_ref2's parent\n\n");
		TEST_RESULT_PRINTF("test_all:get parent error",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR);
		return ABORT_ERR;
	}

	p_root = wilddog_getRoot(p_repo1_ref2);
	if(p_root)
	{
		wilddog_debug_level(WD_DEBUG_LOG, "repo1--ref2--root\n\n");
		wilddog_debug_printUrl(p_root);
		test_results[1].result = TRUE;
		wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n");
		wilddog_destroy(&p_root);
	}
	else
	{
		wilddog_debug_level(WD_DEBUG_LOG, "could not get repo1_ref2's root\n\n");
		TEST_RESULT_PRINTF("test_all:get root error",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR);
		return ABORT_ERR;
	}
	wilddog_debug_level(WD_DEBUG_LOG, "p_repo1_ref1 = %u",( unsigned int)p_repo1_ref1);
	wilddog_debug_printUrl(p_repo1_ref1);
	p_child = wilddog_getChild(p_repo2_ref2, (Wilddog_Str_T *)"c3/d4");
	wilddog_debug_level(WD_DEBUG_LOG, "p_child = %u", ( unsigned int)p_child);
	if(p_child)
	{
		wilddog_debug_level(WD_DEBUG_LOG, "p_repo2_ref2--child\n\n");
		wilddog_debug_printUrl(p_child);
		test_results[2].result = TRUE;
		wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n");
		wilddog_destroy(&p_child);
	}
	else
	{
		wilddog_debug_level(WD_DEBUG_LOG, "could not get p_repo2_ref2's child /c3/d4\n\n");
		TEST_RESULT_PRINTF("test_all:get chile error",TESTFUNCNAME_TABLECASE,TEST_ERR,ABORT_ERR);
		return ABORT_ERR;
	}
	p_parent = wilddog_getParent(p_repo2_ref2);
	if(p_parent)
	{
		wilddog_debug_level(WD_DEBUG_LOG, "repo2--ref2--parent\n\n");
		wilddog_debug_printUrl(p_parent);
		wilddog_debug_level(WD_DEBUG_LOG, "----------------------\n\n\n");
		wilddog_destroy(&p_parent);
	}
	else
	{
		wilddog_debug_level(WD_DEBUG_LOG, "could not get repo2_ref2's parent\n\n");
	}

	wilddog_debug_level(WD_DEBUG_LOG, "\n\ndestroy all ref\n\n");
		
	wilddog_destroy(&p_repo1_ref1);
	wilddog_destroy(&p_repo1_ref2);
	wilddog_destroy(&p_repo2_ref1);
	wilddog_destroy(&p_repo2_ref2);
	
	for(j = 0 ; j < FUNC_NUM; j++)
	{
		if(test_results[j].name)
		{
			printf("%-32s\t%s\n", test_results[j].name, (test_results[j].result == TRUE?("PASS"):("FAIL")));
			if(test_results[j].result != TRUE)
				return -1;
		}
	}
	return 0;
}
//cmd post|get|put|observe appid -p path -t token -d data
int main(int argc, char **argv) {

#ifdef 	WORDS_BIGENDIAN
	printf("WORDS_BIGENDIAN \n");
#endif
	char url[1024];
	char dataInput[1024];
	char token[32];
	memset(url,0,sizeof(url));
	memset(dataInput,0,sizeof(dataInput));
	memset(token,0,sizeof(token));
	cJSON* data;
	int type=1;
	int opt,i;
	int argsDone=0;
	while ((opt = getopt(argc, argv, "t:d:")) != -1) {
		switch (opt) {
		case 't':
			strcpy(token, (const char*)optarg);
			break;
		case 'd':
			strcpy(dataInput, (const char*)optarg);
			printf("test:%s",optarg);
			break;
		}
	}

	for (i = 0; optind < argc; i++, optind++) {
		printf("operation: %s ",argv[optind]);
		if(i==0){
			if(strcmp(argv[optind],"set")==0){
				type=2;
			}
			else if(strcmp(argv[optind],"push")==0){
				type=3;
			}
			else if(strcmp(argv[optind],"delete")==0){
				type=4;
			}
			else if(strcmp(argv[optind],"observe")==0){
				type=5;

			}

		}
		if(i==1){
			strcpy(url,argv[optind]);
			argsDone=1;
		}

	}
	if(!argsDone){
		printf("Usage: cmd set|push|get|observe url -t token -d data \n");
		return 0;
	}

	wilddog_t* client= wilddog_new(url);

	if(!client){
		printf("can't connect to server \n");
		return 0;
	}
	if(strlen(token)>0){
		wilddog_setAuth(client,token);
	}
	wilddog_dump(client,toPrint,sizeof(toPrint));
	printf("%s",toPrint);
	switch (type) {
		case 2:
			//set
			data=cJSON_Parse(dataInput);
			wilddog_set(client,data,onSetComplete);
			break;
		case 3:
			//push
			data=cJSON_Parse(dataInput);
			wilddog_push(client,data,onSetComplete);
			break;
		case 4:
			//delete
			wilddog_delete(client,onSetComplete);
			break;
		case 5:
			//observe
			wilddog_on(client,onData,onQueryComplete);
			break;
		default:
			wilddog_query(client,onQueryComplete);
			break;
	}
	while(1){
		wilddog_trySync(client);

	}

	wilddog_destroy(client);
	return 0;
}