[ANNOUNCEMENT] Waltham: a generic Wayland-style IPC over network

[Pekka Paalanen]

Hi,

if you like the Wayland protocol framework, you will probably like 
Waltham too, especially if you have ever wished it would work over a 
network, not just locally.

Before diving into details, lets set expectations: Waltham is not the 
magic bullet that makes Wayland network-transparent! However, Waltham 
could be an implementation detail in a software suite(*) that allows 
Wayland applications to be ran over a network. In fact, this is the
main motivation behind Waltham: a protocol framework that makes it as
easy as possible to mirror Wayland protocol extensions and replace the 
network-incompatible pieces with something else.

In Wayland, you define your protocol messages in an XML file, use a
code generator to create the message bindings, and let the library do
all the hard work of serializing and deserializing it. The library does
not need to be re-built to support new protocol extensions. Tuned for
optimal performance in a local environment, Wayland protocol cannot
reasonably be sent over a network.

Waltham is (will be) the Wayland-style protocol framework built to 
support network communications. Just like Wayland, the protocol is 
object-oriented, defined in XML files, and you use a code generator to 
bind it in server and client programs. Practically all the Wayland 
protocol design principles apply also to Waltham protocols - if you can 
write Wayland protocols, you can write Waltham protocols.

The major differences from Wayland to Waltham are:
- Waltham uses TCP sockets for communication
- Waltham cannot send file descriptors
- Waltham API is minimal and symmetric between server and client sides
- Waltham does not provide an event loop implementation
- the "registry" implementation is left out of the library, only the 
interface is provided
- no multi-threading support for sharing objects between threads

Many of the differences are design decisions based on lessons learned 
from working with Wayland for years.

The Waltham project can be found here:

	https://github.com/waltham/waltham

The implementation is still missing some major design features, the 
biggest one being that we still have to build the protocol bindings
into the library, but it should be good enough to start playing with.
The road to a stable API and ABI includes also things like deciding how
to secure the communications - right now it is completely insecure. We
are keen to have people join the project and contribute. If interested, 
please contact us via Github.

Collabora is developing Waltham by the request of ADIT (Advanced Driver 
Information Technology), a joint venture company owned by Robert Bosch 
GmbH, Robert Bosch Car Multimedia GmbH and DENSO Corporation.


(*) Software design that prompted for Waltham is the Weston surface 
remoting for IVI:
https://lists.freedesktop.org/archives/wayland-devel/2016-April/027932.html
In that proposal, Waltham plays the role of the "control channel" 
(Section 4.1 in the PDF).


Thanks,
pq
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 801 bytes
Desc: OpenPGP digital signature
URL: <https://lists.freedesktop.org/archives/wayland-devel/attachments/20161028/b1b59138/attachment.sig>