Struct ComHub 

pub struct ComHub {
    pub endpoint: Endpoint,
    pub options: ComHubOptions,
    pub interface_factories: RefCell<HashMap<String, ComInterfaceFactoryFn>>,
    pub interfaces: RefCell<HashMap<ComInterfaceUUID, (Rc<RefCell<dyn ComInterface>>, InterfacePriority)>>,
    pub sockets: RefCell<HashMap<ComInterfaceSocketUUID, (Arc<Mutex<ComInterfaceSocket>>, HashSet<Endpoint>)>>,
    pub endpoint_sockets_blacklist: RefCell<HashMap<Endpoint, HashSet<ComInterfaceSocketUUID>>>,
    pub fallback_sockets: RefCell<Vec<(ComInterfaceSocketUUID, u16, InterfaceDirection)>>,
    pub endpoint_sockets: RefCell<HashMap<Endpoint, Vec<(ComInterfaceSocketUUID, DynamicEndpointProperties)>>>,
    pub block_handler: BlockHandler,
    /* private fields */
}

Fields

endpoint: Endpoint

the runtime endpoint of the hub (@me)

options: ComHubOptions

ComHub configuration options

interface_factories: RefCell<HashMap<String, ComInterfaceFactoryFn>>

a list of all available interface factories, keyed by their interface type

interfaces: RefCell<HashMap<ComInterfaceUUID, (Rc<RefCell<dyn ComInterface>>, InterfacePriority)>>

a list of all available interfaces, keyed by their UUID

sockets: RefCell<HashMap<ComInterfaceSocketUUID, (Arc<Mutex<ComInterfaceSocket>>, HashSet<Endpoint>)>>

a list of all available sockets, keyed by their UUID contains the socket itself and a list of endpoints currently associated with it

endpoint_sockets_blacklist: RefCell<HashMap<Endpoint, HashSet<ComInterfaceSocketUUID>>>

a blacklist of sockets that are not allowed to be used for a specific endpoint

fallback_sockets: RefCell<Vec<(ComInterfaceSocketUUID, u16, InterfaceDirection)>>

fallback sockets that are used if no direct endpoint reachable socket is available sorted by priority

endpoint_sockets: RefCell<HashMap<Endpoint, Vec<(ComInterfaceSocketUUID, DynamicEndpointProperties)>>>

a list of all available sockets for each endpoint, with additional DynamicEndpointProperties metadata

block_handler: BlockHandler

Implementations

impl ComHub

pub fn new(endpoint: impl Into<Endpoint>) -> ComHub

pub async fn init(&self) -> Result<(), ComHubError>

pub fn register_interface_factory( &self, interface_type: String, factory: ComInterfaceFactoryFn, )

Registers a new interface factory for a specific interface implementation. This allows the ComHub to create new instances of the interface on demand.

pub async fn create_interface( &self, interface_type: &str, setup_data: ValueContainer, priority: InterfacePriority, ) -> Result<Rc<RefCell<dyn ComInterface>>, ComHubError>

Creates a new interface instance using the registered factory for the specified interface type if it exists. The interface is opened and added to the ComHub.

pub fn get_interface_by_uuid<T: ComInterface>( &self, interface_uuid: &ComInterfaceUUID, ) -> Option<Rc<RefCell<T>>>

pub fn has_interface(&self, interface_uuid: &ComInterfaceUUID) -> bool

pub fn get_dyn_interface_by_uuid( &self, uuid: &ComInterfaceUUID, ) -> Option<Rc<RefCell<dyn ComInterface>>>

pub async fn open_and_add_interface( &self, interface: Rc<RefCell<dyn ComInterface>>, priority: InterfacePriority, ) -> Result<(), ComHubError>

pub fn add_interface( &self, interface: Rc<RefCell<dyn ComInterface>>, priority: InterfacePriority, ) -> Result<(), ComHubError>

pub async fn remove_interface( &self, interface_uuid: ComInterfaceUUID, ) -> Result<(), ComHubError>

User can proactively remove an interface from the hub. This will destroy the interface and it’s sockets (perform deep cleanup)

pub fn register_socket_endpoint( &self, socket: Arc<Mutex<ComInterfaceSocket>>, endpoint: Endpoint, distance: i8, ) -> Result<(), SocketEndpointRegistrationError>

Registers a new endpoint that is reachable over the socket if the socket is not already registered, it will be added to the socket list. If the provided endpoint is not the same as the socket endpoint, it is registered as an indirect socket to the endpoint

pub async fn wait_for_update_async(&self)

Waits for all background tasks scheduled by the update() function to finish This includes block flushes from flush_outgoing_blocks() and interface (re)-connections from update_interfaces()

pub async fn update_async(&self)

Updates all sockets and interfaces, collecting incoming data and sending out queued blocks. In contrast to the update() function, this function is asynchronous and will wait for all background tasks scheduled by the update() function to finish

pub fn _start_update_loop(self_rc: Rc<Self>)

Runs the update loop for the ComHub. This method will continuously handle incoming data, send out queued blocks and update the sockets. This is only used for internal tests - in a full runtime setup, the main runtime update loop triggers ComHub updates.

pub fn update(&self)

Update all sockets and interfaces, collecting incoming data and sending out queued blocks. Updates are scheduled in local tasks and are not immediately visible. To wait for the block update to finish, use wait_for_update_async().

pub fn send_own_block(&self, block: DXBBlock) -> Result<(), Vec<Endpoint>>

Public method to send an outgoing block from this endpoint. Called by the runtime.

pub async fn send_own_block_await_response( &self, block: DXBBlock, options: ResponseOptions, ) -> Vec<Result<Response, ResponseError>>

Sends a block and wait for a response block. Fix number of exact endpoints -> Expected responses are known at send time. TODO #189: make sure that mutating blocks are always send to specific endpoint instances (@jonas/0001), not generic endpoints like @jonas. @jonas -> response comes from a specific instance of @jonas/0001

pub fn send_block( &self, block: DXBBlock, exclude_sockets: Vec<ComInterfaceSocketUUID>, forked: bool, ) -> Result<(), Vec<Endpoint>>

Sends a block to all endpoints specified in the block header. The routing algorithm decides which sockets are used to send the block, based on the endpoint. A block can be sent to multiple endpoints at the same time over a socket or to multiple sockets for each endpoint. The original_socket parameter is used to prevent sending the block back to the sender. When this method is called, the block is queued in the send queue. Returns an Err with a list of unreachable endpoints if the block could not be sent to all endpoints.

impl ComHub

pub async fn record_trace( &self, endpoint: impl Into<Endpoint>, ) -> Option<NetworkTraceResult>

pub async fn record_trace_with_options( &self, options: TraceOptions, ) -> Option<NetworkTraceResult>

pub async fn record_trace_multiple( &self, endpoints: Vec<impl Into<Endpoint>>, ) -> Vec<NetworkTraceResult>

pub async fn record_trace_multiple_with_options( &self, options: TraceOptions, ) -> Vec<NetworkTraceResult>

Trait Implementations

impl Debug for ComHub

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ComHub

fn default() -> Self

Returns the “default value” for a type.