Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

chore(starknet_sequencer_node): remove option from client struct #2659

Merged
merged 1 commit into from
Dec 15, 2024
+33 −69
Merged

chore(starknet_sequencer_node): remove option from client struct #2659

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
102 changes: 33 additions & 69 deletions crates/starknet_sequencer_node/src/clients.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -42,19 +42,16 @@ use crate::config::component_execution_config::ReactiveComponentExecutionMode;
use crate::config::node_config::SequencerNodeConfig;

pub struct SequencerNodeClients {
batcher_client: Option<Client<BatcherRequest, BatcherResponse>>,
mempool_client: Option<Client<MempoolRequest, MempoolResponse>>,
gateway_client: Option<Client<GatewayRequest, GatewayResponse>>,
// TODO (Lev): Change to Option<Box<dyn MemPoolClient>>.
batcher_client: Client<BatcherRequest, BatcherResponse>,
mempool_client: Client<MempoolRequest, MempoolResponse>,
gateway_client: Client<GatewayRequest, GatewayResponse>,
mempool_p2p_propagator_client:
Option<Client<MempoolP2pPropagatorRequest, MempoolP2pPropagatorResponse>>,
state_sync_client: Option<Client<StateSyncRequest, StateSyncResponse>>,
Client<MempoolP2pPropagatorRequest, MempoolP2pPropagatorResponse>,
state_sync_client: Client<StateSyncRequest, StateSyncResponse>,
}

/// A macro to retrieve a shared client (either local or remote) from a specified field in a struct,
/// returning it wrapped in an `Arc`. This macro simplifies access to a client by checking if a
/// This macro simplifies client access by checking the specified client field and returning the
/// existing client, either local_client or remote_client. Only one will exist at a time.
/// A macro to retrieve a shared client wrapped in an `Arc`. The returned client is either the local
/// or the remote, as at most one of them exists. If neither, it returns `None`.
///
/// # Arguments
///
Expand All @@ -64,8 +61,8 @@ pub struct SequencerNodeClients {
///
/// # Returns
///
/// An Option<Arc<dyn Trait>> containing the available client (local_client or remote_client),
/// wrapped in Arc. If neither client exists, it returns None.
/// An Option<Arc<dyn ClientTrait>> containing the available client (local_client or remote_client),
/// wrapped in Arc. If neither exists, returns None.
///
/// # Example
///
Expand All @@ -81,20 +78,14 @@ pub struct SequencerNodeClients {
/// }
/// }
/// ```
///
/// In this example, `get_shared_client!` checks if `batcher_client` has a local or remote client
/// available. If a local client exists, it returns `Some(Arc::new(local_client))`; otherwise,
/// it checks for a remote client and returns `Some(Arc::new(remote_client))` if available.
/// If neither client is available, it returns `None`.
#[macro_export]
macro_rules! get_shared_client {
($self:ident, $client_field:ident) => {{
if let Some(client) = &$self.$client_field {
if let Some(local_client) = client.get_local_client() {
return Some(Arc::new(local_client));
} else if let Some(remote_client) = client.get_remote_client() {
return Some(Arc::new(remote_client));
}
let client = &$self.$client_field;
if let Some(local_client) = client.get_local_client() {
return Some(Arc::new(local_client));
} else if let Some(remote_client) = client.get_remote_client() {
return Some(Arc::new(remote_client));
}
None
}};
Expand All @@ -109,10 +100,7 @@ impl SequencerNodeClients {
pub fn get_batcher_local_client(
&self,
) -> Option<LocalComponentClient<BatcherRequest, BatcherResponse>> {
match &self.batcher_client {
Some(client) => client.get_local_client(),
None => None,
}
self.batcher_client.get_local_client()
}

pub fn get_mempool_shared_client(&self) -> Option<SharedMempoolClient> {
Expand All @@ -122,10 +110,7 @@ impl SequencerNodeClients {
pub fn get_mempool_local_client(
&self,
) -> Option<LocalComponentClient<MempoolRequest, MempoolResponse>> {
match &self.mempool_client {
Some(client) => client.get_local_client(),
None => None,
}
self.mempool_client.get_local_client()
}

pub fn get_gateway_shared_client(&self) -> Option<SharedGatewayClient> {
Expand All @@ -135,10 +120,7 @@ impl SequencerNodeClients {
pub fn get_gateway_local_client(
&self,
) -> Option<LocalComponentClient<GatewayRequest, GatewayResponse>> {
match &self.gateway_client {
Some(client) => client.get_local_client(),
None => None,
}
self.gateway_client.get_local_client()
}

pub fn get_mempool_p2p_propagator_shared_client(
Expand All @@ -151,10 +133,7 @@ impl SequencerNodeClients {
&self,
) -> Option<LocalComponentClient<MempoolP2pPropagatorRequest, MempoolP2pPropagatorResponse>>
{
match &self.mempool_p2p_propagator_client {
Some(client) => client.get_local_client(),
None => None,
}
self.mempool_p2p_propagator_client.get_local_client()
}

pub fn get_state_sync_shared_client(&self) -> Option<SharedStateSyncClient> {
Expand All @@ -164,16 +143,13 @@ impl SequencerNodeClients {
pub fn get_state_sync_local_client(
&self,
) -> Option<LocalComponentClient<StateSyncRequest, StateSyncResponse>> {
match &self.state_sync_client {
Some(client) => client.get_local_client(),
None => None,
}
self.state_sync_client.get_local_client()
}
}

/// A macro for creating a component client, determined by the component's execution mode. Returns a
/// `Client` containing either a local client if the component is run locally, or a remote client if
/// the execution mode is Remote. Returns None if the execution mode is Disabled.
/// A macro for creating a component client fitting the component's execution mode. Returns a
/// `Client` containing: a local client if the component is run locally, a remote client if
/// the component is run remotely, and neither if the component is disabled.
///
/// # Arguments
///
Expand All @@ -184,14 +160,7 @@ impl SequencerNodeClients {
/// * $remote_client_type - The type for the remote client to create, e.g., RemoteBatcherClient. The
/// client type should have a function $remote_client_type::new(config).
/// * $channel_expr - Sender side for the local client.
/// * $remote_client_config - Configuration for the remote client, passed as Some(config) when
/// available.
///
/// # Returns
///
/// An `Option<Client<...>>` containing either a local or remote client based on the execution mode
/// (LocalExecutionWithRemoteDisabled / LocalExecutionWithRemoteEnabled for local clients, Remote
/// for remote clients), or None if the execution mode is Disabled.
/// * $remote_client_config - Configuration for the remote client, passed as Option(config).
///
/// # Example
///
Expand All @@ -206,11 +175,6 @@ impl SequencerNodeClients {
/// channels.take_batcher_tx(),
/// config.components.batcher.remote_client_config
/// );
///
/// match batcher_client {
/// Some(client) => println!("Client created: {:?}", client),
/// None => println!("Client not created because the execution mode is disabled."),
/// }
/// ```
macro_rules! create_client {
(
Expand All @@ -224,16 +188,16 @@ macro_rules! create_client {
ReactiveComponentExecutionMode::LocalExecutionWithRemoteDisabled
| ReactiveComponentExecutionMode::LocalExecutionWithRemoteEnabled => {
let local_client = Some(<$local_client_type>::new($channel_expr));
Some(Client::new(local_client, None))
Client::new(local_client, None)
}
ReactiveComponentExecutionMode::Remote => match $remote_client_config {
Some(ref config) => {
Some(config) => {
let remote_client = Some(<$remote_client_type>::new(config.clone()));
Some(Client::new(None, remote_client))
Client::new(None, remote_client)
}
None => None,
None => panic!("Remote client configuration is missing."),
},
ReactiveComponentExecutionMode::Disabled => None,
ReactiveComponentExecutionMode::Disabled => Client::new(None, None),
}
};
}
Expand All @@ -247,37 +211,37 @@ pub fn create_node_clients(
LocalBatcherClient,
RemoteBatcherClient,
channels.take_batcher_tx(),
config.components.batcher.remote_client_config
&config.components.batcher.remote_client_config
);
let mempool_client = create_client!(
&config.components.mempool.execution_mode,
LocalMempoolClient,
RemoteMempoolClient,
channels.take_mempool_tx(),
config.components.mempool.remote_client_config
&config.components.mempool.remote_client_config
);
let gateway_client = create_client!(
&config.components.gateway.execution_mode,
LocalGatewayClient,
RemoteGatewayClient,
channels.take_gateway_tx(),
config.components.gateway.remote_client_config
&config.components.gateway.remote_client_config
);

let mempool_p2p_propagator_client = create_client!(
&config.components.mempool_p2p.execution_mode,
LocalMempoolP2pPropagatorClient,
RemoteMempoolP2pPropagatorClient,
channels.take_mempool_p2p_propagator_tx(),
config.components.mempool_p2p.remote_client_config
&config.components.mempool_p2p.remote_client_config
);

let state_sync_client = create_client!(
&config.components.state_sync.execution_mode,
LocalStateSyncClient,
RemoteStateSyncClient,
channels.take_state_sync_tx(),
config.components.state_sync.remote_client_config
&config.components.state_sync.remote_client_config
);

SequencerNodeClients {
Expand Down
Loading