efl_io_queue: basic class to interact with Efl.Io interfaces.
The use of low-level interfaces such as Efl.Io.Reader and Efl.Io.Writer are not that user-friendly as they can handle partial data. Classes such as Efl.Io.Copier makes them easy to use, but they need a reader (source) or writer (destination) and in our examples we used fixed buffers or some existing streams (stdin/stdout/stderr, networking...). However, if interactively we need to produce some data to be sent, such as implementing some networking protocols, we'd have to write our own Efl.Io.Reader and Efl.Io.Writer classes to handle the buffering. Not anymore! With Efl.Io.Queue you can write stuff to it and it will buffer to memory. Once stuff is read, it will automatically remove those bytes from buffer.
This commit is contained in:
Gustavo Sverzut Barbieri
parent
06983d8673
commit
8c23ab0685
|
|
@ -48,5 +48,6 @@
|
|||
/ecore_buffer_provider_example
|
||||
/efl_io_copier_example
|
||||
/efl_io_copier_simple_example
|
||||
/efl_io_queue_example
|
||||
/efl_net_server_example
|
||||
/efl_net_dialer_http_example
|
||||
|
|
|
|||
|
|
@ -79,6 +79,7 @@ ecore_con_eet_client_example \
|
|||
ecore_con_eet_server_example \
|
||||
efl_io_copier_example \
|
||||
efl_io_copier_simple_example \
|
||||
efl_io_queue_example \
|
||||
efl_net_server_example \
|
||||
efl_net_dialer_http_example
|
||||
|
||||
|
|
@ -287,6 +288,9 @@ efl_io_copier_example_LDADD = $(ECORE_CON_COMMON_LDADD)
|
|||
efl_io_copier_simple_example_SOURCES = efl_io_copier_simple_example.c
|
||||
efl_io_copier_simple_example_LDADD = $(ECORE_COMMON_LDADD)
|
||||
|
||||
efl_io_queue_example_SOURCES = efl_io_queue_example.c
|
||||
efl_io_queue_example_LDADD = $(ECORE_CON_COMMON_LDADD)
|
||||
|
||||
efl_net_server_example_SOURCES = efl_net_server_example.c
|
||||
efl_net_server_example_LDADD = $(ECORE_CON_COMMON_LDADD)
|
||||
|
||||
|
|
@ -341,6 +345,7 @@ ecore_con_eet_server_example.c \
|
|||
ecore_con_eet_descriptor_example.c \
|
||||
efl_io_copier_example.c \
|
||||
efl_io_copier_simple_example.c \
|
||||
efl_io_queue_example.c \
|
||||
efl_net_server_example.c \
|
||||
efl_net_dialer_http_example.c
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,374 @@
|
|||
#define EFL_BETA_API_SUPPORT 1
|
||||
#define EFL_EO_API_SUPPORT 1
|
||||
#include <Ecore.h>
|
||||
#include <Ecore_Getopt.h>
|
||||
#include <Ecore_Con.h>
|
||||
|
||||
static int retval = EXIT_SUCCESS;
|
||||
static Eina_List *waiting = NULL;
|
||||
static Eina_List *commands = NULL;
|
||||
static Eina_Slice line_delimiter;
|
||||
static Eo *send_queue, *receive_queue;
|
||||
|
||||
static void
|
||||
_command_next(void)
|
||||
{
|
||||
Eina_Slice slice;
|
||||
char *cmd;
|
||||
|
||||
if (!commands)
|
||||
{
|
||||
efl_io_queue_eos_mark(send_queue);
|
||||
return;
|
||||
}
|
||||
|
||||
cmd = commands->data;
|
||||
commands = eina_list_remove_list(commands, commands);
|
||||
|
||||
slice = (Eina_Slice)EINA_SLICE_STR(cmd);
|
||||
efl_io_writer_write(send_queue, &slice, NULL);
|
||||
fprintf(stderr, "INFO: sent '" EINA_SLICE_STR_FMT "'\n",
|
||||
EINA_SLICE_STR_PRINT(slice));
|
||||
|
||||
/* don't use line_delimiter directly, 'len' may be changed! */
|
||||
slice = line_delimiter;
|
||||
efl_io_writer_write(send_queue, &slice, NULL);
|
||||
free(cmd);
|
||||
}
|
||||
|
||||
static void
|
||||
_receiver_data(void *data EINA_UNUSED, const Eo_Event *event)
|
||||
{
|
||||
Eina_Slice slice;
|
||||
|
||||
if (!efl_io_queue_slice_get(event->object, &slice)) return;
|
||||
|
||||
/* this will happen when we're called when we issue our own
|
||||
* efl_io_queue_clear() below.
|
||||
*/
|
||||
if (slice.len == 0) return;
|
||||
|
||||
if (slice.len < line_delimiter.len)
|
||||
{
|
||||
fprintf(stderr, "ERROR: received short line '" EINA_SLICE_STR_FMT "'\n",
|
||||
EINA_SLICE_STR_PRINT(slice));
|
||||
}
|
||||
else if (memcmp(slice.bytes + slice.len - line_delimiter.len,
|
||||
line_delimiter.bytes, line_delimiter.len) != 0)
|
||||
{
|
||||
fprintf(stderr, "WARNING: received without line-delimiter '"
|
||||
EINA_SLICE_STR_FMT "'\n",
|
||||
EINA_SLICE_STR_PRINT(slice));
|
||||
}
|
||||
else
|
||||
{
|
||||
slice.len -= line_delimiter.len;
|
||||
fprintf(stderr, "INFO: received '" EINA_SLICE_STR_FMT "'\n",
|
||||
EINA_SLICE_STR_PRINT(slice));
|
||||
}
|
||||
|
||||
efl_io_queue_clear(event->object);
|
||||
_command_next();
|
||||
}
|
||||
|
||||
static void
|
||||
_dialer_connected(void *data EINA_UNUSED, const Eo_Event *event)
|
||||
{
|
||||
fprintf(stderr, "INFO: connected to %s (%s)\n",
|
||||
efl_net_dialer_address_dial_get(event->object),
|
||||
efl_net_socket_address_remote_get(event->object));
|
||||
|
||||
_command_next();
|
||||
}
|
||||
|
||||
static void
|
||||
_copier_done(void *data EINA_UNUSED, const Eo_Event *event)
|
||||
{
|
||||
fprintf(stderr, "INFO: %s done\n", efl_name_get(event->object));
|
||||
|
||||
waiting = eina_list_remove(waiting, event->object);
|
||||
if (!waiting)
|
||||
ecore_main_loop_quit();
|
||||
}
|
||||
|
||||
static void
|
||||
_copier_error(void *data EINA_UNUSED, const Eo_Event *event)
|
||||
{
|
||||
const Eina_Error *perr = event->info;
|
||||
fprintf(stderr, "INFO: %s error: #%d '%s'\n",
|
||||
efl_name_get(event->object), *perr, eina_error_msg_get(*perr));
|
||||
retval = EXIT_FAILURE;
|
||||
ecore_main_loop_quit();
|
||||
}
|
||||
|
||||
EFL_CALLBACKS_ARRAY_DEFINE(copier_cbs,
|
||||
{ EFL_IO_COPIER_EVENT_DONE, _copier_done },
|
||||
{ EFL_IO_COPIER_EVENT_ERROR, _copier_error });
|
||||
|
||||
static char *
|
||||
_unescape(const char *str)
|
||||
{
|
||||
char *ret = strdup(str);
|
||||
char *c, *w;
|
||||
Eina_Bool escaped = EINA_FALSE;
|
||||
|
||||
for (c = ret, w = ret; *c != '\0'; c++)
|
||||
{
|
||||
if (escaped)
|
||||
{
|
||||
escaped = EINA_FALSE;
|
||||
switch (*c)
|
||||
{
|
||||
case 'n': *w = '\n'; break;
|
||||
case 'r': *w = '\r'; break;
|
||||
case 't': *w = '\t'; break;
|
||||
default: w++; /* no change */
|
||||
}
|
||||
w++;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (*c == '\\')
|
||||
escaped = EINA_TRUE;
|
||||
else
|
||||
w++;
|
||||
}
|
||||
}
|
||||
*w = '\0';
|
||||
return ret;
|
||||
}
|
||||
|
||||
static const Ecore_Getopt options = {
|
||||
"efl_io_queue_example", /* program name */
|
||||
NULL, /* usage line */
|
||||
"1", /* version */
|
||||
"(C) 2016 Enlightenment Project", /* copyright */
|
||||
"BSD 2-Clause", /* license */
|
||||
/* long description, may be multiline and contain \n */
|
||||
"Example of Efl_Io_Queue usage.\n"
|
||||
"\n"
|
||||
"This uses Efl_Io_Queue to easily interface with Efl_Io_Copier in order to "
|
||||
"send commands to a TCP server.",
|
||||
EINA_FALSE,
|
||||
{
|
||||
ECORE_GETOPT_STORE_STR('d', "line-delimiter",
|
||||
"Changes the line delimiter to be used in both send and receive. Defaults to \\r\\n"),
|
||||
ECORE_GETOPT_STORE_ULONG('l', "buffer-limit",
|
||||
"If set will limit buffer size to this limit of bytes. If used alongside with --line-delimiter and that delimiter was not found but bffer limit was reached, the line event will be triggered without the delimiter at the end."),
|
||||
ECORE_GETOPT_VERSION('V', "version"),
|
||||
ECORE_GETOPT_COPYRIGHT('C', "copyright"),
|
||||
ECORE_GETOPT_LICENSE('L', "license"),
|
||||
ECORE_GETOPT_HELP('h', "help"),
|
||||
|
||||
ECORE_GETOPT_STORE_METAVAR_STR(0, NULL,
|
||||
"The server address as\n"
|
||||
"IP:PORT to connect using TCP and an IPv4 (A.B.C.D:PORT) or IPv6 ([A:B:C:D::E]:PORT).\n",
|
||||
"server_address"),
|
||||
ECORE_GETOPT_APPEND_METAVAR(0, NULL,
|
||||
"Commands to send",
|
||||
"commands",
|
||||
ECORE_GETOPT_TYPE_STR),
|
||||
ECORE_GETOPT_SENTINEL
|
||||
}
|
||||
};
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
char *address = NULL;
|
||||
char *line_delimiter_str = NULL;
|
||||
char *cmd;
|
||||
unsigned long buffer_limit = 0;
|
||||
Eina_Bool quit_option = EINA_FALSE;
|
||||
Ecore_Getopt_Value values[] = {
|
||||
ECORE_GETOPT_VALUE_STR(line_delimiter_str),
|
||||
ECORE_GETOPT_VALUE_ULONG(buffer_limit),
|
||||
|
||||
/* standard block to provide version, copyright, license and help */
|
||||
ECORE_GETOPT_VALUE_BOOL(quit_option), /* -V/--version quits */
|
||||
ECORE_GETOPT_VALUE_BOOL(quit_option), /* -C/--copyright quits */
|
||||
ECORE_GETOPT_VALUE_BOOL(quit_option), /* -L/--license quits */
|
||||
ECORE_GETOPT_VALUE_BOOL(quit_option), /* -h/--help quits */
|
||||
|
||||
/* positional argument */
|
||||
ECORE_GETOPT_VALUE_STR(address),
|
||||
ECORE_GETOPT_VALUE_LIST(commands),
|
||||
|
||||
ECORE_GETOPT_VALUE_NONE /* sentinel */
|
||||
};
|
||||
Eina_Error err;
|
||||
int args;
|
||||
Eo *dialer, *sender, *receiver, *loop;
|
||||
|
||||
ecore_init();
|
||||
ecore_con_init();
|
||||
|
||||
args = ecore_getopt_parse(&options, values, argc, argv);
|
||||
if (args < 0)
|
||||
{
|
||||
fputs("ERROR: Could not parse command line options.\n", stderr);
|
||||
retval = EXIT_FAILURE;
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (quit_option) goto end;
|
||||
|
||||
args = ecore_getopt_parse_positional(&options, values, argc, argv, args);
|
||||
if (args < 0)
|
||||
{
|
||||
fputs("ERROR: Could not parse positional arguments.\n", stderr);
|
||||
retval = EXIT_FAILURE;
|
||||
goto end;
|
||||
}
|
||||
|
||||
line_delimiter_str = _unescape(line_delimiter_str ? line_delimiter_str : "\\r\\n");
|
||||
|
||||
if (!commands)
|
||||
{
|
||||
fputs("ERROR: missing commands to send.\n", stderr);
|
||||
retval = EXIT_FAILURE;
|
||||
goto end;
|
||||
}
|
||||
|
||||
line_delimiter = (Eina_Slice)EINA_SLICE_STR(line_delimiter_str);
|
||||
|
||||
/*
|
||||
* Without a send_queue we'd have to manually implement an
|
||||
* Efl_Io_Reader object that would provide partial data when
|
||||
* Efl_Io_Reader.read() is called by Efl_Io_Copier. This is
|
||||
* cumbersome... we just want to write a full command and have the
|
||||
* queue to handle that for us.
|
||||
*
|
||||
* Our example's usage is to write each command at once followed by
|
||||
* the line_delimiter, then wait for a reply from the server, then
|
||||
* write another.
|
||||
*/
|
||||
send_queue = efl_add(EFL_IO_QUEUE_CLASS, NULL,
|
||||
efl_name_set(efl_self, "send_queue"),
|
||||
efl_io_queue_limit_set(efl_self, buffer_limit));
|
||||
if (!send_queue)
|
||||
{
|
||||
fprintf(stderr, "ERROR: could not create Efl_Io_Queue (send)\n");
|
||||
retval = EXIT_FAILURE;
|
||||
goto end;
|
||||
}
|
||||
|
||||
/*
|
||||
* Without a receive_queue we'd have to manually implement an
|
||||
* Efl_Io_Writer object that would handle write of partial data
|
||||
* with Efl_Io_Writer.write() is called by Efl_Io_Copier.
|
||||
*
|
||||
* For output we could have another solution as well: use NULL
|
||||
* destination and handle "line" or "data" events manually,
|
||||
* stealing the buffer so it doesn't grow.
|
||||
*
|
||||
* Our example's usage is to peek its data with slice_get() then
|
||||
* clear().
|
||||
*/
|
||||
receive_queue = efl_add(EFL_IO_QUEUE_CLASS, NULL,
|
||||
efl_name_set(efl_self, "receive_queue"),
|
||||
efl_io_queue_limit_set(efl_self, buffer_limit),
|
||||
efl_event_callback_add(efl_self, EFL_IO_QUEUE_EVENT_SLICE_CHANGED, _receiver_data, NULL));
|
||||
if (!receive_queue)
|
||||
{
|
||||
fprintf(stderr, "ERROR: could not create Efl_Io_Queue (receive)\n");
|
||||
retval = EXIT_FAILURE;
|
||||
goto error_receive_queue;
|
||||
}
|
||||
|
||||
/*
|
||||
* From here on it's mostly the same all Efl_Io_Copier would do,
|
||||
* check efl_io_copier_simple_example.c and efl_io_copier_example.c
|
||||
*/
|
||||
|
||||
/*
|
||||
* some objects such as the Efl.Io.Copier and Efl.Net.Dialer.Tcp
|
||||
* depend on main loop, thus their parent must be a loop
|
||||
* provider. We use the loop itself.
|
||||
*/
|
||||
loop = ecore_main_loop_get();
|
||||
|
||||
/* The TCP client to use to send/receive network data */
|
||||
dialer = efl_add(EFL_NET_DIALER_TCP_CLASS, loop,
|
||||
efl_name_set(efl_self, "dialer"),
|
||||
efl_event_callback_add(efl_self, EFL_NET_DIALER_EVENT_CONNECTED, _dialer_connected, NULL));
|
||||
if (!dialer)
|
||||
{
|
||||
fprintf(stderr, "ERROR: could not create Efl_Net_Dialer_Tcp\n");
|
||||
retval = EXIT_FAILURE;
|
||||
goto error_dialer;
|
||||
}
|
||||
|
||||
/* sender: send_queue->network */
|
||||
sender = efl_add(EFL_IO_COPIER_CLASS, loop,
|
||||
efl_name_set(efl_self, "sender"),
|
||||
efl_io_copier_line_delimiter_set(efl_self, &line_delimiter),
|
||||
efl_io_copier_source_set(efl_self, send_queue),
|
||||
efl_io_copier_destination_set(efl_self, dialer),
|
||||
efl_event_callback_array_add(efl_self, copier_cbs(), NULL));
|
||||
if (!sender)
|
||||
{
|
||||
fprintf(stderr, "ERROR: could not create Efl_Io_Copier (sender)\n");
|
||||
retval = EXIT_FAILURE;
|
||||
goto error_sender;
|
||||
}
|
||||
|
||||
/* receiver: network->receive_queue */
|
||||
receiver = efl_add(EFL_IO_COPIER_CLASS, loop,
|
||||
efl_name_set(efl_self, "receiver"),
|
||||
efl_io_copier_line_delimiter_set(efl_self, &line_delimiter),
|
||||
efl_io_copier_source_set(efl_self, dialer),
|
||||
efl_io_copier_destination_set(efl_self, receive_queue),
|
||||
efl_event_callback_array_add(efl_self, copier_cbs(), NULL));
|
||||
if (!receiver)
|
||||
{
|
||||
fprintf(stderr, "ERROR: could not create Efl_Io_Copier (receiver)\n");
|
||||
retval = EXIT_FAILURE;
|
||||
goto error_receiver;
|
||||
}
|
||||
|
||||
err = efl_net_dialer_dial(dialer, address);
|
||||
if (err)
|
||||
{
|
||||
fprintf(stderr, "ERROR: could not dial %s: %s\n",
|
||||
address, eina_error_msg_get(err));
|
||||
goto error_dialing;
|
||||
}
|
||||
|
||||
waiting = eina_list_append(waiting, sender);
|
||||
waiting = eina_list_append(waiting, receiver);
|
||||
|
||||
ecore_main_loop_begin();
|
||||
|
||||
if (waiting)
|
||||
{
|
||||
fprintf(stderr, "ERROR: %d operations were waiting!\n",
|
||||
eina_list_count(waiting));
|
||||
eina_list_free(waiting);
|
||||
waiting = NULL;
|
||||
}
|
||||
|
||||
error_dialing:
|
||||
efl_io_closer_close(receiver);
|
||||
efl_del(receiver);
|
||||
error_receiver:
|
||||
efl_io_closer_close(sender);
|
||||
efl_del(sender);
|
||||
error_sender:
|
||||
efl_del(dialer);
|
||||
error_dialer:
|
||||
efl_del(receive_queue);
|
||||
error_receive_queue:
|
||||
efl_del(send_queue);
|
||||
end:
|
||||
EINA_LIST_FREE(commands, cmd)
|
||||
{
|
||||
fprintf(stderr, "ERROR: unsent command: %s\n", cmd);
|
||||
free(cmd);
|
||||
}
|
||||
|
||||
ecore_con_shutdown();
|
||||
ecore_shutdown();
|
||||
|
||||
return retval;
|
||||
}
|
||||
Loading…
Reference in New Issue