ipc::Protocol Class Reference

#include <protocol.h>

Public Member Functions
virtual	~Protocol ()=default
virtual std::unique_ptr< interfaces::Init >	connect (int fd, const char *exe_name)=0
virtual void	listen (int listen_fd, const char *exe_name, interfaces::Init &init)=0
virtual void	serve (int fd, const char *exe_name, interfaces::Init &init, const std::function< void()> &ready_fn={})=0
virtual void	disconnectIncoming ()=0
	Disconnect any incoming connections that are still connected.
virtual void	addCleanup (std::type_index type, void *iface, std::function< void()> cleanup)=0
virtual Context &	context ()=0
	Context accessor.

Detailed Description

IPC protocol interface for calling IPC methods over sockets.

There may be different implementations of this interface for different IPC protocols (e.g. Cap'n Proto, gRPC, JSON-RPC, or custom protocols).

Definition at line 21 of file protocol.h.

Constructor & Destructor Documentation

~Protocol()

virtual ipc::Protocol::~Protocol ( )

virtualdefault

Member Function Documentation

addCleanup()

virtual void ipc::Protocol::addCleanup ( std::type_index type, void * iface, std::function< void()> cleanup )

pure virtual

Add cleanup callback to interface that will run when the interface is deleted.

connect()

virtual std::unique_ptr< interfaces::Init > ipc::Protocol::connect ( int fd, const char * exe_name )

pure virtual

Return Init interface that forwards requests over given socket descriptor. Socket communication is handled on a background thread.

Note

It could be potentially useful in the future to add std::function<void()> on_disconnect callback argument here. But there isn't an immediate need, because the protocol implementation can clean up its own state (calling ProxyServer destructors, etc) on disconnect, and any client calls will just throw ipc::Exception errors after a disconnect.

context()

virtual Context & ipc::Protocol::context ( )

pure virtual

Context accessor.

disconnectIncoming()

virtual void ipc::Protocol::disconnectIncoming ( )

pure virtual

Disconnect any incoming connections that are still connected.

listen()

virtual void ipc::Protocol::listen ( int listen_fd, const char * exe_name, interfaces::Init & init )

pure virtual

Listen for connections on provided socket descriptor, accept them, and handle requests on accepted connections. This method doesn't block, and performs I/O on a background thread.

serve()

virtual void ipc::Protocol::serve ( int fd, const char * exe_name, interfaces::Init & init, const std::function< void()> & ready_fn = {} )

pure virtual

Handle requests on provided socket descriptor, forwarding them to the provided Init interface. Socket communication is handled on the current thread, and this call blocks until the socket is closed.

Note

: If this method is called, it needs be called before connect() or listen() methods, because for ease of implementation it's inflexible and always runs the event loop in the foreground thread. It can share its event loop with the other methods but can't share an event loop that was created by them. This isn't really a problem because serve() is only called by spawned child processes that call it immediately to communicate back with parent processes.

The optional ready_fn callback will be called after the event loop is created but before it is started. This can be useful in tests to trigger client connections from another thread as soon as the event loop is available, but should not be necessary in normal code which starts clients and servers independently.

---

The documentation for this class was generated from the following file:

• src/ipc/protocol.h