Commit Graph

66 Commits

Author SHA1 Message Date
Guilherme Iscaro c35e929713 Add new Future/Promise API.
Summary:
Eina: Add Eina_Promise/Eina_Future.

This commit adds a new promise/future API which aims to replace
efl_future.

Efl_Object: Add integration with Eina_Future.

This commit adds the EO support for the new future infra.
From now on there's no need to efl_future_link()/efl_future_unlink()
object and futures since the new API already handles that internally.

Eina_Promise/Eina_Future: Add example and tests.

Subscribers: cedric, jpeg

Differential Revision: https://phab.enlightenment.org/D5131
2017-08-25 20:42:23 -03:00
Gustavo Sverzut Barbieri fa0e2865a1 implement efl_net_{socket,dialer,server}_windows
This is the local socket for windows, analogous to AF_UNIX.

`Efl_Net_Socket_Windows` is the base class doing `ReadFile()` and
`WriteFile()` using overlapped I/O, as well as the close procedure
(`FlushFileBuffers()`, `DisconnectNamedPipe()` and
`CloseHandle()`). These are done on top of an existing HANDLE that is
set by `Efl_Net_Dialer_Windows` (from `CreateFile()`) or
`Efl_Net_Server_Windows` (from `CreateNamedPipe()`).

The overlapped I/O will return immediately, either with operation
completed or `ERROR_IO_PENDING`, which means the kernel will execute
that asynchronously and will later `SetEvent(overlapped.hEvent)` which
is an event we wait on our main loop. That `overlapped` handle must
exist during the call lifetime, thus cannot be bound to `pd`, as we
may call `CancelIo()` but there is no guarantee the memory won't be
touched, in that case we keep the overlapped around, but without an
associated object.

Windows provides no notification "can read without blocking" or
non-blocking calls that returns partial data. The way to go is to use
these overlapped I/O, with an initial `ReadFile()` to an internal
buffer, once that operation finishes, we callback the user to says
there is something to read (`efl_io_reader_can_read_set()`) and wait
until `efl_io_reader_read()` is called to consume the available data,
then `ReadFile()` is called again to read more data to the same
internal buffer.

Likewise, there is no "can write without blocking" or non-blocking
calls that sends only partial data. The way to go is to get user bytes
in `efl_io_writer_write()` and copy them in an internal buffer, then
call `WriteFile()` on that and inform the user nothing else can be
written until that operation completes
(`efl_io_writer_can_write_set()`).

This is cumbersome since we say we "sent" stuff when we actually
didn't, it's still in our internal buffer (`pd->send.bytes`), but
nonetheless the kernel and the other peer may be adding even more
buffers, in this case we need to do a best effort to get it
delivery. A particular case is troublesome: `write() -> close()`, this
may result in `WriteFile()` pending, in this case we wait using
`GetOverlappedResult()`, *this is nasty and may block*, but it's the
only way I see to cope with such common use case.

Other operations, like ongoing `ReadFile()` or `ConnectNamedPipe()`
will be canceled using `CancelIo()`.

Q: Why no I/O Completion Port (IOCP) was used? Why no
   CreateThreadpoolIo()? These perform much better!

A: These will call back from secondary threads, but in EFL we must
   report back to the user in order to process incoming data or get
   more data to send. That is, we serialize everything to the main
   thread, making it impossible to use the benefits of IOCP and
   similar such as CreateThreadpoolIo(). Since we'd need to wakeup the
   main thread anyways, using `OVERLAPPED.hEvent` with
   `ecore_main_win32_handler_add()` does the job as we expect.

Thanks to Vincent Torri (vtorri) for his help getting this code done
with an example on how to do the NamedPipe handling on Windows.
2017-03-29 12:44:19 -03:00
Guilherme Iscaro 87e458838d Ecore Evas: Add a new cursor example.
This example sets the cursor image of each available mouse and
report its position every one second.
2016-12-20 18:34:39 -02:00
Gustavo Sverzut Barbieri 633ec445b8 efl_net: add Efl.Net.Ip_Address
This is a string parser, serializer and asynchronous resolver.

It's purpose is to convert to and from the strings we use in our
dialers and servers, such as "127.0.0.1:1234" or "[::1]:1234",
properties allow to check the family, port, address bytes (slice) and
even get a struct sockaddr pointer to use with bind()/connect() in
outside code.

It will also offer some utilities present in netinet/in.h in an easy
to use way, after all IN6_IS_ADDR_LOOPBACK() works one way, while
there is no IN_LOOPBACK and comparing with INADDR_LOOPBACK will lead
to errors since it's in network order.

Last but not least, it will do asynchronous resolve of host and port
names using an internal thread and getaddrinfo(). The results are
delivered using a Future with an array of objects.
2016-12-12 02:30:33 -02:00
Gustavo Sverzut Barbieri d07e0c3072 examples/ecore: build ecore_con_url_ftp_example 2016-11-29 16:03:13 -02:00
Gustavo Sverzut Barbieri 167ff29ea0 efl_net_{socket,dialer,server}_simple: easy to use, buffered network sockets.
The low level I/O primitives are powerful but adds some complexity to
use, for bi-directional streaming communication one ends creating two
Efl.Io.Queue and two Efl.Io.Copier to pipe data to socket when it can
operate.

Then encapsulate the socket using the new Efl.Io.Buffered_Stream, this
will allow the socket, be a dialer or a server client, to be operated
as a single handle that internally carries about the buffering for
you.

As one can see in the examples, compared to their "manual"
alternatives they are very easy to use, ressembling
Ecore_Con_Server/Ecore_Con_Client, but also offers line-based
delimiters and the possibility to let the socket to handle queueing
for you in case you received partial messages (just do not
read/clear/discard the received data).
2016-11-25 17:27:32 -02:00
Gustavo Sverzut Barbieri 46341b329d efl_io_buffered_stream: wraps an I/O object and make it easy to use.
Since all other efl.io objects are low-level, the recommended approach
is to use an efl.io.copier. However when dealing with in-memory,
bi-directional comms like talking to a socket, we always end with 2
queues, 2 copiers and the annoying setup that is being replicated in
ecore_ipc, efl_debug and so on.

This class is the base to make it simpler. Other classes such as
Efl.Net.Socket.Simple, Efl.Net.Dialer.Simple and Efl.Net.Server.Simple
will use it to provide simpler code to users.

I guess we can call EFL+EO Java now?
2016-11-25 17:27:32 -02:00
Gustavo Sverzut Barbieri 06263c9eb3 add ecore_ipc_{client,server}_example.
Ecore_Ipc lacked examples so we can explore its API (and check if it
work :-P)
2016-11-22 19:50:11 -02:00
Gustavo Sverzut Barbieri 98fe627ca4 efl_net_session and efl_net_control for ConnMan
These are objects to allow control of networking devices
(efl_net_control) as well as an application to request for
connectivity (efl_net_session).

They are loosely based on ConnMan.org, which we already use in
Enlightenment Window Manager via DBus access with Eldbus. However they
do not map 1:1 as the goal was to expose a viable subset of controls
but in a simple and general way, thus nome strings were converted to
enums, some arrays of strings were converted to bitwise flags, some
names were made more general, such as "service" was turned into
"access point" so it doesn't generate confusion with other "network
services" (ie: http server), or "favorite" that was renamed to
"remembered". Some behavior are slightly different (yet able to be
implemented on top), such as "Service.MoveBefore" and "MoveAfter" were
converted to a numeric "priority", calculated from service's list
index, changing the priority will reoder the list and thus generate
the MoveBefore and MoveAfter DBus commands.

ConnMan was chosen not only because we already use it, but because its
DBus API is sane and simple, with the server doing almost all that we
need. This is visible in the efl_net_session, which is completely done
in the server and do not require any extra work on our side -- aside
from talking DBus and converting to Eo, which is a major work :-D

   NOTE: ConnMan doesn't use FreeDesktop.Org DBus interfaces such as
         Properties and ObjectManager, thus we cannot use
         eldbus_model_object.

There are two examples added:

 - efl_net_session_example: monitors the connection available for an
   application and try to connect. You need a connman compiled with
   session_policy_local and a configuration file explained in
   https://github.com/aldebaran/connman/blob/master/doc/session-policy-format.txt
   to get a connection if nothing is connected. Otherwise it will just
   monitor the connectivity state.

 - efl_net_control_example: monitors, plays the agent and configure
   the network details. It can enable/disable technologies, connect to
   access points (services) and configure them. It's quite extensive
   as allows testing all of ConnMan's DBus API except P2P (Peers).
2016-11-08 22:40:34 -02:00
Bruno Dilly 3bc2793588 examples/ecore: add example / test for wayland multiseat 2016-11-01 16:06:19 -02:00
Gustavo Sverzut Barbieri 15a0ca0fb9 examples/ecore: command to generate OpenSSL PEM files.
it's cumbersome to remember these commands and without them it's hard
to test the SSL server examples, so add a make rule for that.
2016-11-01 11:52:21 -02:00
Gustavo Sverzut Barbieri f4198f022a efl_net_socket_ssl: initial SSL wrapper.
This is the first step towards SSL connections on top of sockets, with
an example on how to upgrade a dialer and a server client using TCP.
2016-10-31 19:39:33 -02:00
Gustavo Sverzut Barbieri 651ff13616 addded efl_net_{socket,dialer,server}_unix
This introduces AF_UNIX server and dialer, these are not available on
Windows as in that platform we'll create a custom class for native
'local' communication.

In the future we can add a wrapper class Efl.Net.Local that will use
the class for each platform, but won't expose its details.

For instance, if we ever expose 'credentials' (which I didn't because
they are not portable), then it doesn't make sense to try to match
that on Windows. The 'Efl.Net.Local' would just stick to the basics:
Reader, Writer and Closer APIs.
2016-10-26 19:01:03 -02:00
Gustavo Sverzut Barbieri 278866da2c efl_net_dialer_udp: "connect" to an UDP server to send and receive data.
Like existing ecore_con code, this does not use SOCKSv5 UDP
proxy. It's kinda cumbersome to add since requires a keep alive TCP
connection to the server, a second UDP channel and framing around the
original UDP frame.

Added UDP_CORK (if present) to match TCP_UDP present in TCP sockets,
this allows one to execute multiple write() calls that will result in
a single datagram, generated when CORK becomes FALSE again.

The efl_io_copier_example.c now accepts this as output. There is no
input UDP as there is no way to notify the server of a connection
(since such thing doesn't exit), usually servers react after a
datagram is received, replying to the source.
2016-10-18 19:04:00 -02:00
Bruno Dilly 8cb4a943ba examples/ecore: add example suffix to ecore_evas_vnc
Make its name similar to all the other example
files on this folder.
2016-09-28 14:42:58 -03:00
Bruno Dilly e2afcc0ab4 examples/ecore: fix vnc example build
Fix missing dependency.

Get rid of the following error:

/usr/bin/ld: ecore_evas_vnc.o: undefined reference
  to symbol 'ECORE_EVENT_MOUSE_BUTTON_UP'
src/lib/ecore_input/.libs/libecore_input.so.1: error adding symbols:
  DSO missing from command line
collect2: error: ld returned 1 exit status
Makefile:2306: recipe for target 'ecore_evas_vnc' failed
2016-09-28 14:42:58 -03:00
Guilherme Iscaro 03824e520e Examples: Add an Ecore Evas VNC example.
This commit adds an Ecore_Evas examples that can be used to test
the VNC multi-seat support.
2016-09-26 22:06:59 -03:00
Gustavo Sverzut Barbieri e12afd772c efl_net_dialer_websocket: EFL now does WebSocket!
The Efl.Net.Dialer.Websocket is just like other Efl.Net.Dialers: you
can dial, you can close, monitor connected/address resolved and so
on. And you can use WebSocket primitives and events such as
text_send(), binary_send(), ping() and close_request() (since
WebSockets use a close process where you should state a close
reason). See efl_net_dialer_websocket_example.c

Even if WebSocket is a message-based protocol (like "packets" from
UDP), you can use efl_net_dialer_websocket_streaming_mode_set() to
tell it to handle text or binary messages as a stream. Then all the
Efl.Io.Reader and Efl.Io.Writer APIs work as expected, see
efl_io_copier_example.c updates.
2016-09-02 00:08:50 -03:00
Gustavo Sverzut Barbieri 86e87b2fd9 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.
2016-08-23 20:17:13 -03:00
Gustavo Sverzut Barbieri db46d4c1a3 examples: add efl_io_copier_simple_example.c
a simpler example to be listed in wiki.
2016-08-23 12:05:37 -03:00
Gustavo Sverzut Barbieri b791c79ca0 WIP: efl.net: Introduce Efl.Net.Dialer.Http
This class implements the Efl.Net.Dialer interface using libcurl to
perform HTTP requests. That means it's an Efl.Net.Dialer,
Efl.Net.Socket, Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus
being usable with Efl.Io.Copier as demonstrated in the
efl_io_copier_example.c
2016-08-22 18:25:15 -03:00
Gustavo Sverzut Barbieri e7df1a7483 efl.net: socket, server and dialer for TCP.
Efl.Net.Server defines how to accept new connections, doing the
bind(), listen() and accept() for protocols such as TCP.

Efl.Net.Dialer defines to to reach a server.

Both are based on Efl.Net.Socket as communication interface that is
based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being
usable with code such as Efl.Io.Copier.

The Server will emit an event "client,add" with the established
Socket, which is a child and can be closed by both the server or the
user.

The Dialer extends the Socket and allows for creating one given an
address, that will be resolved and connected.

TCP is the initial implementation so we an validate the
interfaces. UDP, Unix-Local and SSL will come later as derivate
classes.

The examples are documented and should cover the basic principles:

 - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a
   "netcat", can send data from socket, file or stdin to a socket,
   file, stdout or stderr.

 - efl_net_server_example listens for connections and can either reply
   "Hello World!" and take some data or work as an echo-server,
   looping back all received data to the user.

More complex interactions that require a "chat" between client and
server will be covered with new classes later, such as a queue that
empties itself once data is read.
2016-08-22 18:25:14 -03:00
Gustavo Sverzut Barbieri 5d4688679e efl.io: introduce basic interfaces and classes.
These interfaces allows generic operations on objects that can store
or provide data, such as a file or a buffer.

With well defined interfaces and events we can create code such as
Efl.Io.Copier, that will link a source with a destination and
progressively copy data as they appear.
2016-08-22 18:25:14 -03:00
Stefan Schmidt 2471d962ed examples: ecore: do not try to install files which are not available
The ecore_audio examples have been disabled and now do not compile right now.
But as they are disabled they never land in the tarball and thus we error out
with files not aviavle for install. Found by the OpenSUSE build service. Thanks
Simotek for reporting.

[ 2172s] /home/abuild/rpmbuild/BUILD/efl-1.17.99.47400/install-sh: ecore_audio_custom.c does not
exist.
2016-06-07 14:20:17 +02:00
Stefan Schmidt d1a2f1c724 examples: ecore: add all needed files to SOURCES to make sure they are distributed
This worked in-tree but never landed in a distribution tarball and thus the
examples build form such a tarball would fail.
2016-05-18 12:17:16 +02:00
Jean-Philippe Andre 6826ce1c6f Examples: Fix compilation (disable CXX examples!)
Warning: This disables CXX examples because they use
now-internal APIs that have no EO API binding.
Those examples should be updated to use Efl.Ui widgets... once
we have them.
2016-04-21 17:16:53 +09:00
Cedric BAIL fb759c7b90 examples: add DESTDIR support for install. 2016-04-14 17:00:08 -07:00
David Walter Seikel 14b2ba7bed ecore - let the ecore_con_eet_*.c examples build.
When using the --enable-always-build-examples configure option, these two
examples need to be linked to eet.

@fix
2015-09-11 14:19:36 +10:00
Stefan Schmidt 1e2fd2be07 examples: Fix build after ecore_buffer commit.
Since 8b62177561 make examples fails to build
as the examples have been included without checking if ecore_buffer is
actually enabled to build.

make[2]: *** No rule to make target '../../../src/lib/ecore_buffer/libecore_buffer.la', needed by 'ecore_buffer_example'.  Stop.

I'm running make examples during the nightlies now in the hope to catch those.
2015-06-24 13:46:43 +02:00
Seunghun Lee 8b62177561 ecore-buffer: Add ecore_buffer library to EFL.
Summary:
Ecore_Buffer is abstraction of graphic buffer.
it supports backend of shm, x11_dri2 and x11_dri3 for now,
and this library also provides method to share buffers between processes.
Ecore_Buffer_Provider and Ecore_Buffer_Consumer is for this, sharing buffer.
provider draws something in to Ecore_Buffer, and consumer receives and displays it.
the binary, bq_mgr is a connection maker for buffer provider and consumer.
it can be included Enlightenment as a deamon later.

@feature

Test Plan:
1. Configure with --enable-ecore-buffer and --enable-always-build-examples to build examples.
2. Run bq_mgr, it connects consumer and provider.
3. Run ecore_buffer_provider_example and ecore_buffer_consumer_example

Reviewers: lsj119, gwanglim, cedric, zmike, jpeg, raster, devilhorns

Subscribers: cedric

Differential Revision: https://phab.enlightenment.org/D2197
2015-06-22 10:31:42 -04:00
Felipe Magno de Almeida 7a9bf994de Fix ecore_con_eet_client_example example compilation error
Added eet to include flags for Makefile.am for ecore examples
2015-04-23 22:20:16 -03:00
Cedric BAIL e866b42de5 ecore: build newly added Ecore_Con examples. 2015-04-22 15:10:20 +02:00
Cedric BAIL 0914115586 emile: build examples after adding emile. 2015-03-17 09:58:19 +01:00
Stefan Schmidt c5879dab4d build: Unify use of $(MKDIR_P) for creating a dir within the build system
While we used different variation of mkdir -p all over we also had spots
where we did not use the option. This is one step in trying to make our
build system ready for parallel install. Using something like -j 10 even
for the install should help to speed up our jenkins jobs as well as distcheck.
2015-02-25 16:43:35 +01:00
Wonguk Jeong 171d9bc135 ecore: fix example build fail (ecore_compose_get_example) 2014-07-29 02:11:17 +02:00
Savio Sena 073b666022 autotools: Fixed 'make examples' and 'make examples-install'
It was broken in set-ups with ($(builddir) != $(srcdir)) && ($(builddir) !=
$(srcdir)/build)
2014-07-02 20:01:09 -03:00
Tom Hacohen 7ef3b0530d Ecore examples: Add ecore_compose_get() example.
Example created by Vincent Torri.
2014-06-30 17:42:58 +01:00
Vincent Torri a3f8ec0e0c autotools: really don't build Unix specific example on Windows
Signed-off-by: Cedric BAIL <cedric.bail@samsung.com>
2014-01-10 16:34:56 +09:00
Cedric BAIL 3ceaaa0c79 ecore: don't build Unix specific example on Windows. 2014-01-09 10:17:14 +09:00
Gustavo Sverzut Barbieri 1c1f9ea0e1 add great ecore_getopt example.
should cover and explain getopt usage and serve as base for
applications that want to use it (all efl should!)
2013-12-17 18:08:27 -02:00
U. Artie Eoff 4606c0b95e examples/ecore: don't use ECORE_CON_LIBS
We can't use ECORE_CON_LIBS at the examples/ "make" context
since it defines libraries relative to the src/ directory
(e.g. lib/ecore/libecore.la).  Use ECORE_CON_COMMON_LDADD instead.

This fixes the following link error with ecore_fd_handler_gnutls_example
when the project is configured with --with-crypto=gnutls:

libtool: link: cannot find the library `lib/ecore/libecore.la'

Signed-off-by: U. Artie Eoff <ullysses.a.eoff@intel.com>
2013-10-01 13:53:29 -07:00
U. Artie Eoff 65b11e98c8 examples/ecore: ecore_pipe_gstreamer_example must go in HAVE_GSTREAMER guard
Only specify ecore_pipe_gstreamer_example in EXTRA_PROGRAMS inside the
HAVE_GSTREAMER makefile guard.

Fixes: https://phab.enlightenment.org/T423

Signed-off-by: U. Artie Eoff <ullysses.a.eoff@intel.com>
2013-10-01 13:46:57 -07:00
Daniel Willmann 4c2c42034c ecore example: Disable ecore_audio examples while Eo is in flux
There is no legacy API we could use here, so just disable building for
now.
2013-07-24 08:57:05 +02:00
Carsten Haitzler f2b1039e05 fix examples makefiles to find Efl_Config.h 2013-04-25 02:08:49 +09:00
Daniel Willmann 6df9640c10 ecore_audio: Make custom input example work with eo
Uses VIO to implement a custom read function

Signed-off-by: Daniel Willmann <d.willmann@samsung.com>
2013-04-18 19:16:38 +01:00
Daniel Willmann f96ba47976 ecore_audio: Implement ecore_audio_playback example with eo
Signed-off-by: Daniel Willmann <d.willmann@samsung.com>
2013-04-18 19:15:37 +01:00
Daniel Willmann 9da64ff201 ecore_audio: Update transcoding example to work with eo
Signed-off-by: Daniel Willmann <d.willmann@samsung.com>
2013-04-18 19:14:25 +01:00
Daniel Willmann 48b78234a8 ecore_audio: Build Eo-based Ecore_Audio and tests now
Signed-off-by: Daniel Willmann <d.willmann@samsung.com>
2013-04-18 19:12:17 +01:00
Tom Hacohen 6ceabe7fa6 Revert "Fix build break"
This doesn't really fix build break, it actually breaks it.

This reverts commit e655f0b735.
2013-02-15 16:19:35 +00:00
Jaehwan Kim e655f0b735 Fix build break 2013-02-15 20:15:58 +09:00