GRIN/nym
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

epoch in client-gateway, nym-api does not compile

Browse Source
This commit is contained in:
Simon Wicky
2023-08-03 11:00:53 +02:00
parent 6e3a84b759
commit 0d81c7d765
6 changed files with 61 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/client-core/src/client/base_client/mod.rs
+17
View File
@@ -42,6 +42,9 @@ use nym_sphinx::receiver::{ReconstructedMessage, SphinxMessageReceiver};
use nym_task::connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
use nym_task::{TaskClient, TaskManager};
use nym_topology::provider_trait::TopologyProvider;
use nym_validator_client::NymApiClient;
use rand::seq::SliceRandom;
use rand::thread_rng;
use std::sync::Arc;
use tap::TapFallible;
use url::Url;
@@ -298,6 +301,7 @@ where
bandwidth_controller: Option<BandwidthController<C, S::CredentialStore>>,
mixnet_message_sender: MixnetMessageSender,
ack_sender: AcknowledgementSender,
api_client: NymApiClient,
shutdown: TaskClient,
) -> Result<GatewayClient<C, S::CredentialStore>, ClientCoreError>
where
@@ -326,6 +330,7 @@ where
ack_sender,
config.debug.gateway_connection.gateway_response_timeout,
bandwidth_controller,
api_client,
shutdown,
);
@@ -343,6 +348,15 @@ where
Ok(gateway_client)
}
fn random_api_client(&self) -> nym_validator_client::NymApiClient {
let endpoints = self.config.get_nym_api_endpoints();
let nym_api = endpoints
.choose(&mut thread_rng())
.expect("The list of validator apis is empty");
nym_validator_client::NymApiClient::new(nym_api.clone())
}
fn setup_topology_provider(
custom_provider: Option<Box<dyn TopologyProvider + Send + Sync>>,
nym_api_urls: Vec<Url>,
@@ -474,6 +488,8 @@ where
let gateway_config = details.gateway_details;
let managed_keys = details.managed_keys;
let random_api_client = self.random_api_client();
let (reply_storage_backend, credential_store) = self.client_store.into_runtime_stores();
let bandwidth_controller = self
@@ -517,6 +533,7 @@ where
bandwidth_controller,
mixnet_messages_sender,
ack_sender,
random_api_client,
task_manager.subscribe(),
)
.await?;
common/client-core/src/init/helpers.rs
+3
View File
@@ -9,6 +9,7 @@ use nym_crypto::asymmetric::{encryption, identity};
use nym_gateway_client::GatewayClient;
use nym_gateway_requests::registration::handshake::SharedKeys;
use nym_topology::{filter::VersionFilterable, gateway};
use nym_validator_client::NymApiClient;
use rand::{seq::SliceRandom, Rng};
use std::{sync::Arc, time::Duration};
use tap::TapFallible;
@@ -201,6 +202,7 @@ pub(super) async fn register_with_gateway(
gateway: &GatewayEndpointConfig,
our_identity: Arc<identity::KeyPair>,
our_sphinx: Arc<encryption::KeyPair>,
nym_api_client: NymApiClient,
) -> Result<Arc<SharedKeys>, ClientCoreError> {
let timeout = Duration::from_millis(1500);
let mut gateway_client: GatewayClient<DirectSigningNyxdClient, _> = GatewayClient::new_init(
@@ -210,6 +212,7 @@ pub(super) async fn register_with_gateway(
our_identity.clone(),
our_sphinx.clone(),
timeout,
nym_api_client,
);
gateway_client
.establish_connection()
common/client-core/src/init/mod.rs
+12 -1
View File
@@ -17,7 +17,9 @@ use nym_crypto::asymmetric::identity;
use nym_sphinx::addressing::{clients::Recipient, nodes::NodeIdentity};
use nym_topology::gateway;
use nym_validator_client::client::IdentityKey;
use nym_validator_client::NymApiClient;
use rand::rngs::OsRng;
use rand::seq::SliceRandom;
use serde::Serialize;
use std::fmt::{Debug, Display};
use url::Url;
@@ -271,6 +273,7 @@ pub async fn setup_gateway_from<K, D>(
details_store: &D,
overwrite_data: bool,
gateways: Option<&[gateway::Node]>,
nym_api_client: NymApiClient,
) -> Result<InitialisationDetails, ClientCoreError>
where
K: KeyStore,
@@ -374,7 +377,8 @@ where
// Establish connection, authenticate and generate keys for talking with the gateway
let shared_keys =
helpers::register_with_gateway(&gateway_details, our_identity, our_sphinx).await?;
helpers::register_with_gateway(&gateway_details, our_identity, our_sphinx, nym_api_client)
.await?;
let persisted_details = PersistedGatewayDetails::new(gateway_details, &shared_keys);
@@ -411,12 +415,19 @@ where
let mut rng = OsRng;
let gateways = current_gateways(&mut rng, validator_servers.unwrap_or_default()).await?;
let nym_api = validator_servers
.unwrap_or_default()
.choose(&mut rng)
.ok_or(ClientCoreError::ListOfNymApisIsEmpty)?;
let client = nym_validator_client::client::NymApiClient::new(nym_api.clone());
setup_gateway_from(
setup,
key_store,
details_store,
overwrite_data,
Some(&gateways),
client,
)
.await
}
common/client-libs/gateway-client/src/client.rs
+15 -1
View File
@@ -23,6 +23,7 @@ use nym_network_defaults::{REMAINING_BANDWIDTH_THRESHOLD, TOKENS_TO_BURN};
use nym_noise::upgrade_noise_initiator;
use nym_sphinx::forwarding::packet::MixPacket;
use nym_task::TaskClient;
use nym_validator_client::NymApiClient;
use rand::rngs::OsRng;
use std::convert::TryFrom;
use std::net::SocketAddr;
@@ -60,6 +61,7 @@ pub struct GatewayClient<C, St> {
packet_router: PacketRouter,
response_timeout_duration: Duration,
bandwidth_controller: Option<BandwidthController<C, St>>,
nym_api_client: NymApiClient,
// reconnection related variables
/// Specifies whether client should try to reconnect to gateway on connection failure.
@@ -89,6 +91,7 @@ impl<C, St> GatewayClient<C, St> {
ack_sender: AcknowledgementSender,
response_timeout_duration: Duration,
bandwidth_controller: Option<BandwidthController<C, St>>,
nym_api_client: NymApiClient,
shutdown: TaskClient,
) -> Self {
GatewayClient {
@@ -105,6 +108,7 @@ impl<C, St> GatewayClient<C, St> {
packet_router: PacketRouter::new(ack_sender, mixnet_message_sender, shutdown.clone()),
response_timeout_duration,
bandwidth_controller,
nym_api_client,
should_reconnect_on_failure: true,
reconnection_attempts: DEFAULT_RECONNECTION_ATTEMPTS,
reconnection_backoff: DEFAULT_RECONNECTION_BACKOFF,
@@ -180,12 +184,20 @@ impl<C, St> GatewayClient<C, St> {
Ok(stream_res) => match stream_res {
Ok(stream) => {
debug!("Managed to establish connection to gateway");
let current_epoch_id = match self.nym_api_client.get_current_epoch_id().await {
Ok(epoch_id) => epoch_id,
Err(err) => {
error!("Failed to retrieve epoch Id for Noise handshake - {err}");
return Err(GatewayClientError::ConnectionNotEstablished);
}
};
let noise_stream = match upgrade_noise_initiator(
stream,
None, //as a client, the gateway cannot know my pub key
&self.local_sphinx.private_key().to_bytes(),
&self.gateway_sphinx.to_bytes(),
0,
current_epoch_id,
)
.await
{
@@ -830,6 +842,7 @@ impl<C> GatewayClient<C, EphemeralCredentialStorage> {
local_identity: Arc<identity::KeyPair>,
local_sphinx: Arc<encryption::KeyPair>,
response_timeout_duration: Duration,
nym_api_client: NymApiClient,
) -> Self {
use futures::channel::mpsc;
@@ -854,6 +867,7 @@ impl<C> GatewayClient<C, EphemeralCredentialStorage> {
packet_router,
response_timeout_duration,
bandwidth_controller: None,
nym_api_client,
should_reconnect_on_failure: false,
reconnection_attempts: DEFAULT_RECONNECTION_ATTEMPTS,
reconnection_backoff: DEFAULT_RECONNECTION_BACKOFF,
gateway/src/node/client_handling/websocket/listener.rs
+13 -1
View File
@@ -9,6 +9,7 @@ use log::*;
use nym_crypto::asymmetric::{encryption, identity};
use nym_mixnet_client::forwarder::MixForwardingSender;
use nym_noise::upgrade_noise_responder;
use nym_validator_client::NymApiClient;
use rand::rngs::OsRng;
use std::net::SocketAddr;
use std::process;
@@ -21,6 +22,7 @@ pub(crate) struct Listener {
local_sphinx: Arc<encryption::KeyPair>,
only_coconut_credentials: bool,
pub(crate) coconut_verifier: Arc<CoconutVerifier>,
nym_api_client: NymApiClient,
}
impl Listener {
@@ -30,6 +32,7 @@ impl Listener {
local_sphinx: Arc<encryption::KeyPair>,
only_coconut_credentials: bool,
coconut_verifier: Arc<CoconutVerifier>,
nym_api_client: NymApiClient,
) -> Self {
Listener {
address,
@@ -37,6 +40,7 @@ impl Listener {
local_sphinx,
only_coconut_credentials,
coconut_verifier,
nym_api_client,
}
}
@@ -72,12 +76,20 @@ impl Listener {
trace!("received a socket connection from {remote_addr}");
// TODO: I think we *REALLY* need a mechanism for having a maximum number of connected
// clients or spawned tokio tasks -> perhaps a worker system?
let current_epoch_id = match self.nym_api_client.get_current_epoch_id().await {
Ok(epoch_id) => epoch_id,
Err(err) => {
error!("Failed to retrieve epoch Id for Noise handshake - {err}");
return;
}
};
let noise_stream = match upgrade_noise_responder(
socket,
&self.local_sphinx.public_key().to_bytes(),
&self.local_sphinx.private_key().to_bytes(),
None, //connection from client, no remote pub key
0,
current_epoch_id,
)
.await
{
gateway/src/node/mod.rs
+1
View File
@@ -179,6 +179,7 @@ impl<St> Gateway<St> {
Arc::clone(&self.sphinx_keypair),
self.config.gateway.only_coconut_credentials,
coconut_verifier,
self.random_api_client(),
)
.start(
forwarding_channel,