libcaf  0.15.3
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Friends | List of all members
caf::io::middleman Class Referenceabstract

Manages brokers and network backends. More...

#include <middleman.hpp>

Inheritance diagram for caf::io::middleman:
caf::actor_system::module

Public Types

using hook_vector = std::vector< hook_uptr >
 
using backend_pointer = std::unique_ptr< network::multiplexer >
 Smart pointer for network::multiplexer.
 
using backend_factory = std::function< backend_pointer()>
 Used to initialize the backend during construction.
 
- Public Types inherited from caf::actor_system::module
enum  id_t {
  scheduler,
  middleman,
  opencl_manager,
  num_ids
}
 

Public Member Functions

expected< uint16_t > open (uint16_t port, const char *cstr=nullptr, bool ru=false)
 Tries to open a port for other CAF instances to connect to. More...
 
expected< void > close (uint16_t port)
 Closes port port regardless of whether an actor is published to it.
 
expected< node_idconnect (std::string host, uint16_t port)
 Tries to connect to given node. More...
 
template<class Handle >
expected< uint16_t > publish (Handle &&whom, uint16_t port, const char *in=nullptr, bool reuse=false)
 Tries to publish whom at port and returns either an error or the bound port. More...
 
expected< uint16_t > publish_local_groups (uint16_t port, const char *in=nullptr)
 Makes all local groups accessible via network on address addr and port. More...
 
template<class Handle >
expected< void > unpublish (const Handle &whom, uint16_t port=0)
 Unpublishes whom by closing port or all assigned ports if port == 0. More...
 
template<class ActorHandle = actor>
expected< ActorHandle > remote_actor (std::string host, uint16_t port)
 Establish a new connection to the actor at host on given port. More...
 
expected< group > remote_group (const std::string &group_uri)
 <group-name><host>:<port>
 
expected< group > remote_group (const std::string &group_identifier, const std::string &host, uint16_t port)
 
actor_systemsystem ()
 Returns the enclosing actor system.
 
middleman_actor actor_handle ()
 Returns a handle to the actor managing the middleman singleton.
 
template<class Impl >
actor named_broker (atom_value name)
 Returns the broker associated with name or creates a new instance of type Impl. More...
 
template<class F >
void run_later (F fun)
 Runs fun in the event loop of the middleman. More...
 
virtual network::multiplexerbackend ()=0
 Returns the IO backend used by this middleman.
 
template<hook::event_type Event, typename... Ts>
void notify (Ts &&...ts)
 Invokes the callback(s) associated with given event.
 
bool has_hook () const
 Returns whether this middleman has any hooks installed.
 
const hook_vector & hooks () const
 Returns all installed hooks.
 
strong_actor_ptr remote_lookup (atom_value name, const node_id &nid)
 Returns the actor associated with name at nid or invalid_actor if nid is not connected or has no actor associated to this name. More...
 
template<class Handle >
expected< Handle > remote_spawn (const node_id &nid, std::string name, message args, duration timeout=duration(time_unit::minutes, 1))
 
template<class Handle , class Rep , class Period >
expected< Handle > remote_spawn (const node_id &nid, std::string name, message args, std::chrono::duration< Rep, Period > timeout)
 
void start () override
 Starts any background threads needed by the module.
 
void stop () override
 Stops all background threads of the module.
 
void init (actor_system_config &) override
 Allows the module to change the configuration of the actor system during startup. More...
 
id_t id () const override
 Returns the identifier of this module.
 
void * subtype_ptr () override
 Returns a pointer to the subtype.
 
template<spawn_options Os = no_spawn_options, class F = std::function<void(broker*)>, class... Ts>
infer_handle_from_fun< F >::type spawn_broker (F fun, Ts &&...xs)
 Spawns a new functor-based broker.
 
template<spawn_options Os = no_spawn_options, class F = std::function<void(broker*)>, class... Ts>
expected< typename infer_handle_from_fun< F >::type > spawn_client (F fun, const std::string &host, uint16_t port, Ts &&...xs)
 Returns a new functor-based broker connected to host:port or an error. More...
 
template<spawn_options Os = no_spawn_options, class F = std::function<void(broker*)>, class... Ts>
expected< typename infer_handle_from_fun< F >::type > spawn_server (F fun, uint16_t &port, Ts &&...xs)
 Spawns a new broker as server running on given port. More...
 
template<spawn_options Os = no_spawn_options, class F = std::function<void(broker*)>, class... Ts>
expected< typename infer_handle_from_fun< F >::type > spawn_server (F fun, const uint16_t &port, Ts &&...xs)
 Spawns a new broker as server running on given port. More...
 

Static Public Member Functions

static actor_system::modulemake (actor_system &, detail::type_list<>)
 Returns a middleman using the default network backend.
 
template<class Backend >
static actor_system::modulemake (actor_system &sys, detail::type_list< Backend >)
 

Protected Member Functions

 middleman (actor_system &sys)
 

Friends

class actor_system
 

Detailed Description

Manages brokers and network backends.

Member Function Documentation

expected<node_id> caf::io::middleman::connect ( std::string  host,
uint16_t  port 
)

Tries to connect to given node.

Attention
This feature is experimental.
void caf::io::middleman::init ( actor_system_config )
overridevirtual

Allows the module to change the configuration of the actor system during startup.

Implements caf::actor_system::module.

template<class Impl >
actor caf::io::middleman::named_broker ( atom_value  name)

Returns the broker associated with name or creates a new instance of type Impl.

expected<uint16_t> caf::io::middleman::open ( uint16_t  port,
const char *  cstr = nullptr,
bool  ru = false 
)

Tries to open a port for other CAF instances to connect to.

Attention
This feature is experimental.
template<class Handle >
expected<uint16_t> caf::io::middleman::publish ( Handle &&  whom,
uint16_t  port,
const char *  in = nullptr,
bool  reuse = false 
)

Tries to publish whom at port and returns either an error or the bound port.

Parameters
whomActor that should be published at port.
portUnused TCP port.
inThe IP address to listen to or INADDR_ANY if in == nullptr.
reuseCreate socket using SO_REUSEADDR.
Returns
The actual port the OS uses after bind(). If port == 0 the OS chooses a random high-level port.
expected<uint16_t> caf::io::middleman::publish_local_groups ( uint16_t  port,
const char *  in = nullptr 
)

Makes all local groups accessible via network on address addr and port.

Returns
The actual port the OS uses after bind(). If port == 0 the OS chooses a random high-level port.
template<class ActorHandle = actor>
expected<ActorHandle> caf::io::middleman::remote_actor ( std::string  host,
uint16_t  port 
)

Establish a new connection to the actor at host on given port.

Parameters
hostValid hostname or IP address.
portTCP port.
Returns
An actor to the proxy instance representing a remote actor or an error.
strong_actor_ptr caf::io::middleman::remote_lookup ( atom_value  name,
const node_id nid 
)

Returns the actor associated with name at nid or invalid_actor if nid is not connected or has no actor associated to this name.

Note
Blocks the caller until nid responded to the lookup or an error occurred.
template<class Handle >
expected<Handle> caf::io::middleman::remote_spawn ( const node_id nid,
std::string  name,
message  args,
duration  timeout = duration(time_unit::minutes, 1) 
)
Attention
This feature is experimental.
template<class Handle , class Rep , class Period >
expected<Handle> caf::io::middleman::remote_spawn ( const node_id nid,
std::string  name,
message  args,
std::chrono::duration< Rep, Period >  timeout 
)
Attention
This feature is experimental.
template<class F >
void caf::io::middleman::run_later ( fun)

Runs fun in the event loop of the middleman.

Note
This member function is thread-safe.
template<spawn_options Os = no_spawn_options, class F = std::function<void(broker*)>, class... Ts>
expected<typename infer_handle_from_fun<F>::type> caf::io::middleman::spawn_client ( fun,
const std::string &  host,
uint16_t  port,
Ts &&...  xs 
)

Returns a new functor-based broker connected to host:port or an error.

Warning
Blocks the caller for the duration of the connection process.
template<spawn_options Os = no_spawn_options, class F = std::function<void(broker*)>, class... Ts>
expected<typename infer_handle_from_fun<F>::type> caf::io::middleman::spawn_server ( fun,
uint16_t &  port,
Ts &&...  xs 
)

Spawns a new broker as server running on given port.

Warning
Blocks the caller until the server socket is initialized.
template<spawn_options Os = no_spawn_options, class F = std::function<void(broker*)>, class... Ts>
expected<typename infer_handle_from_fun<F>::type> caf::io::middleman::spawn_server ( fun,
const uint16_t &  port,
Ts &&...  xs 
)

Spawns a new broker as server running on given port.

Warning
Blocks the caller until the server socket is initialized.
template<class Handle >
expected<void> caf::io::middleman::unpublish ( const Handle &  whom,
uint16_t  port = 0 
)

Unpublishes whom by closing port or all assigned ports if port == 0.

Parameters
whomActor that should be unpublished at port.
portTCP port.

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