1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

//This method is used by the server to save a message sent by the client
   //use a asynchronous call. This way the server is not blocked during the execution of the query !
   Message Get(Message msg)
   <%
	printf("Store in database: %s\n", msg->msg);
 
	//create our data
	Test_Data *data = calloc(1,sizeof(Test_Data));
	data->msg = msg;
	data->m = module;
	//
 
	//Esskyuehl
	Esql *e;
 
	e = esql_new(ESQL_TYPE_MYSQL);
	data->e = e;
	esql_database_set(e, "tests");
 
	//connect to the mysql database
	esql_connect_callback_set(e, _connect, data);
	esql_connect(e, "127.0.0.1:" ESQL_DEFAULT_PORT_MYSQL, "USER", "PASSWORD);
	//
 
	//suspend azy (only the current call) during the treatment of the sql query
	//consequently azy can treat others client demand
	//when the query will be done, we will resume this instance
	azy_server_module_events_suspend(module);
   %>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

static void _callback(Esql_Res *res, void *data)
{
	Test_Data *d = data;
	Azy_Value *v;
	Azy_Content *content;
 
	printf("Message saved!\n");
 
 
	//disconnect from the mysql db
	esql_disconnect(d->e);
 
	//set the return value of the azy call
	//we return a copy of the message sent by the client
	v = Demo_Message_to_azy_value(d->msg);
   	content = azy_server_module_content_get(d->m);
   	azy_content_retval_set(content, v);
	//
 
        //resume the azy call instance
	azy_server_module_events_resume(d->m);
 
	//free our data
	free(d);
}
 
void _connect(Esql *e, void *data)
{
	Test_Data *d = data;
	Esql_Query_Id id;
 
	//execute the query
	//the second argument is a data you can set and then retrieve it in _callabck()
	id = esql_query_args(e, d, "INSERT INTO messages values('%s');", d->msg->msg);
	if (!id) /**< queue up a simple query */
	{
		fprintf(stderr, "Could not create query!\n");
		ecore_main_loop_quit();
	}
	esql_query_callback_set(id, _callback);
}
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

__download__
<%
    const char *namespace = NULL, *action = NULL;
    const char *p, *p2;
    const char *path;
    Eina_Bool ret = EINA_FALSE;
    int iid = 0;
 
    //retrieve a copy of the path, we will work on it
    path = eina_stringshare_add(azy_net_uri_get(net_));
 
    //first char of the path must be '/'
    EINA_SAFETY_ON_TRUE_GOTO(*path != '/', error);
 
    //then we retrieve the namespace, the action and the id
    p = strchr(path + 1, '/');
    EINA_SAFETY_ON_NULL_GOTO(p, error);
 
    /* grab namespace */
    namespace = eina_stringshare_add_length(path + 1, p - path - 1);
    EINA_SAFETY_ON_TRUE_GOTO((!namespace) || (!namespace[0]), error);
 
    p2 = strchr(p + 1, '/');
    EINA_SAFETY_ON_NULL_GOTO(p2, error);
 
    action = eina_stringshare_add_length(p + 1, p2 - p - 1);
    EINA_SAFETY_ON_TRUE_GOTO((!action) || (!action[0]), error);
    errno = 0;
    iid = strtol(p2 + 1, NULL, 10);
 
    //If we have no ID, the path id is invalid
    EINA_SAFETY_ON_TRUE_GOTO((errno == ERANGE && (iid == LONG_MAX || iid == LONG_MIN))
            || (errno && (!iid)), error);
 
    //print the result
    printf("namespace=%s, action=%s, id=%d\n", namespace, action, iid);
 
    //create the response, here we set the HTTP code 200 because everything is ok
    azy_net_code_set(net_, 200);
    azy_net_header_set(net_, "Content-Type", "image/jpg");
    //
 
    if(!strcmp(namespace, "Photo")
            && !strcmp(action, "Get"))
    {
        //here we should use the iid to retrieve the image
        //in this example we always return the same image
        const char *file = "./initial.jpg";
 
        /*
           we are gonna use mmap to set the image as content
         */
        //copy the file content and sent it
        int fd = open(file, O_RDONLY);
        struct stat st;
        fstat(fd, &st); /* use fstat to get the size */
        unsigned char *content_file = mmap(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
 
        Azy_Net_Data azy_data;
        azy_data.data = content_file;
        azy_data.size = st.st_size;
        azy_server_module_send(module, net_, &azy_data);
        munmap(content_file, st.st_size); /* unmap mmapped data */
        close(fd);
        ret = EINA_TRUE;
        //
    }
 
    eina_stringshare_del(path);
    eina_stringshare_del(namespace);
    eina_stringshare_del(action);
 
    return ret;
error:
    eina_stringshare_del(namespace);
    eina_stringshare_del(action);
    azy_net_code_set(net_, 404);
    azy_server_module_send(module, net_, NULL);
    return EINA_TRUE;
%>
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

/**
 * Yes we are connected !
 */
static Eina_Bool
connected(void *data, int type, Azy_Client *cli)
{
   Azy_Client_Call_Id id;
 
   //we ask the photo id to the server
   azy_net_uri_set(azy_client_net_get(cli), "/Photo/Get/4");
   azy_net_version_set(azy_client_net_get(cli), 0); /* disconnect after sending */
   id = azy_client_blank(cli, AZY_NET_TYPE_GET, NULL, NULL);
   azy_client_callback_set(cli, id, _get);
 
   return ECORE_CALLBACK_RENEW;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

/**
 * This method is called when we have received the photo
 */
static Eina_Error
_get(Azy_Client *cli, Azy_Content *content, void *ret)
{
	const char *FILEPATH = "./FILE_GET.jpg";
	int fd;
	int *map;
 
	if (azy_content_error_is_set(content))
	{
		printf("Error encountered: %s\n", azy_content_error_message_get(content));
		azy_client_close(cli);
		ecore_main_loop_quit();
		return azy_content_error_code_get(content);
	}
 
        //retrieve the size and the content
	int size = azy_content_return_size_get(content);
	unsigned char* data = (unsigned char*)azy_content_return_get(content);
 
        printf("FILE RECEIVED\n");
	printf("Write file in %s\n", FILEPATH);
	printf("File size : %d\n", size);
 
        //open the output file
	fd = open(FILEPATH, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600);
        //write at the end of the file in order to really create it.
	lseek(fd, size-1, SEEK_SET);
	write(fd, "", 1);
	map = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 
        //copy the content into the output file
	memcpy(map, data, size);
 
	munmap(map, size);
	close(fd);
 
        //upload the received file to the server
        _upload(cli);
 
	return AZY_ERROR_NONE;
 }

1
2
3
4

- watchwolf::19:38:26 [64] -> ./server 
__Download__
namespace=Photo, action=Get, id=4
 

1
2
3
4

- watchwolf::19:37:51 [26] -> ./client 
FILE RECEIVED
Write file in ./FILE_GET.jpg
File size : 92722

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

 
        /*
           Methods called when azy receive a PUT HTTP request.
         */
    __upload__
    <%
    const char *namespace = NULL, *action = NULL;
    const char *p, *p2;
    const char *path;
    Eina_Bool ret = EINA_FALSE;
    int iid = 0;
 
    printf("__Upload__\n");
    //retrieve a copy of the path, we will work on it
    path = eina_stringshare_add(azy_net_uri_get(net_));
 
    //first char of the path must be '/'
    EINA_SAFETY_ON_TRUE_GOTO(*path != '/', error);
 
    //then we retrieve the namespace, the action and the id
    p = strchr(path + 1, '/');
    EINA_SAFETY_ON_NULL_GOTO(p, error);
 
    /* grab namespace */
    namespace = eina_stringshare_add_length(path + 1, p - path - 1);
    EINA_SAFETY_ON_TRUE_GOTO((!namespace) || (!namespace[0]), error);
 
    p2 = strchr(p + 1, '/');
    EINA_SAFETY_ON_NULL_GOTO(p2, error);
 
    action = eina_stringshare_add_length(p + 1, p2 - p - 1);
    EINA_SAFETY_ON_TRUE_GOTO((!action) || (!action[0]), error);
    errno = 0;
    iid = strtol(p2 + 1, NULL, 10);
 
    //If we have no ID, the path id is invalid
    EINA_SAFETY_ON_TRUE_GOTO((errno == ERANGE && (iid == LONG_MAX || iid == LONG_MIN))
            || (errno && (!iid)), error);
 
    //print the result
    printf("namespace=%s, action=%s, id=%d\n", namespace, action, iid);
 
    //create the response, here we set the HTTP code 200 because everything is ok
    azy_net_code_set(net_, 200);
    azy_net_header_set(net_, "Content-Type", "image/jpg");
    //
 
    if(!strcmp(namespace, "Photo")
            && !strcmp(action, "Put"))
    {
        //save the image received
        const char *FILEPATH = "./FILE_PUT.jpg";
 
        //retrieve the size and the content
        Azy_Net_Data *data = azy_server_module_recv_get(module);
 
        printf("FILE RECEIVED\n");
        printf("Write file in %s\n", FILEPATH);
        printf("File size : %d\n", (int)data->size);
 
        //open the output file
        int fd = open(FILEPATH, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600);
        //write at the end of the file in order to really create it.
        lseek(fd, data->size-1, SEEK_SET);
        write(fd, "", 1);
        int *map = mmap(0, data->size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 
        //copy the content into the output file
        memcpy(map, data->data, data->size);
 
        munmap(map, data->size);
        close(fd);
    }
 
    eina_stringshare_del(path);
    eina_stringshare_del(namespace);
    eina_stringshare_del(action);
 
    return ret;
error:
    eina_stringshare_del(namespace);
    eina_stringshare_del(action);
 
    azy_net_code_set(net_, 404);
    azy_server_module_send(module, net_, NULL);
    return EINA_TRUE;
    %>
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

//this code is closed to the code of __download__
    const char *file = "./FILE_GET.jpg";
 
    printf("Sending the file %s\n", file);
    /*
       we are gonna use mmap to set the image as content
       */
    //copy the file content and sent it
    int fd = open(file, O_RDONLY);
    struct stat st;
    fstat(fd, &st); /* use fstat to get the size */
    unsigned char *content_file = mmap(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
 
    Azy_Net_Data azy_data;
    azy_data.data = content_file;
    azy_data.size = st.st_size;
 
    //upload
    azy_net_uri_set(azy_client_net_get(cli), "/Photo/Put/4");
    Azy_Client_Call_Id id = azy_client_put(cli, &azy_data, NULL);
    azy_client_callback_set(cli, id, _put);
    //
 
    munmap(content_file, st.st_size); /* unmap mmapped data */
    close(fd);

1

edje_player explode.edj

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

//Describe a dog
typedef struct
{
	const char *name;
	const char *race;
} Dog;
 
 
//describe 2 list of dogs
typedef struct
{
	Eina_List *dogs_I_have;
	Eina_List *dogs_I_add;
} Dogs;
 
 
// Add a dog in the list
Eina_List *dog_add(Eina_List *l, const char* name, const char* race)
{
	Dog *dog = calloc(1, sizeof(Dog));
	dog->name = eina_stringshare_add(name);
	dog->race = eina_stringshare_add(race);
	l = eina_list_append(l, dog);
	return l;
}
 
//Free a dog
void dog_free(Dog *dog)
{
	eina_stringshare_del(dog->name);
	eina_stringshare_del(dog->race);
	free(dog);
}
 
//print a dog
void dog_print(Dog *dog)
{
	printf("\tDog : %s, Race : %s\n", dog->name, dog->race);
}
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

//create the eet descriptor of the struct Dog
static Eet_Data_Descriptor * dog_edd_new()
{
	Eet_Data_Descriptor *edd;
	Eet_Data_Descriptor_Class eddc;
 
	EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Dog);
 
	//set to null because wu use eina_stringshare
	eddc.func.str_direct_alloc = NULL;
	eddc.func.str_direct_free = NULL;
 
	edd = eet_data_descriptor_file_new(&eddc);
 
	EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Dog, "name", name, EET_T_STRING);
	EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Dog, "race", race, EET_T_STRING);
 
	return edd;
}
 
//create the eet descriptor of the struct Dogs
static Eet_Data_Descriptor * dogs_edd_new()
{
	Eet_Data_Descriptor *edd;
	Eet_Data_Descriptor_Class eddc;
 
	Eet_Data_Descriptor *edd_dog = dog_edd_new();
 
	EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Dogs);
 
	//set to null because wu use eina_stringshare
	eddc.func.str_direct_alloc = NULL;
	eddc.func.str_direct_free = NULL;
 
	edd = eet_data_descriptor_file_new(&eddc);
 
	EET_DATA_DESCRIPTOR_ADD_LIST(edd, Dogs, "dog_I_have", dogs_I_have, edd_dog);
	EET_DATA_DESCRIPTOR_ADD_LIST(edd, Dogs, "dog_I_add", dogs_I_add, edd_dog);
 
	return edd;
}
 

1
2
3
4
5
6
7
8
9
10
11
12
13

//create
	Dogs *dogs = calloc(1, sizeof(Dogs));
	dogs->dogs_I_have = NULL;
	dogs->dogs_I_add = NULL;
 
	dogs->dogs_I_have = dog_add(dogs->dogs_I_have, "Mystrale", "Shepherd german");	
	dogs->dogs_I_have = dog_add(dogs->dogs_I_have, "fiona", "Malinois");
 
	dogs->dogs_I_add = dog_add(dogs->dogs_I_add, "Effy", "Czechoslovakian Wolfdogs");	
	dogs->dogs_I_add = dog_add(dogs->dogs_I_add, "Sai", "No race");
	//