85 lines
2.8 KiB
Rust
85 lines
2.8 KiB
Rust
use std::net::{IpAddr, Ipv4Addr};
|
|
use std::time::Duration;
|
|
|
|
use crate::load_keyring;
|
|
use crate::{
|
|
log,
|
|
rho::connection::GeneralConnection,
|
|
util::{file_util::load_file_vec, logger::PrintType},
|
|
};
|
|
use mtp::crypto::PublicKeyBundle;
|
|
use mtp::host::{AuthenticationPolicy, Host, HostConfig, Policy, SendMode};
|
|
|
|
pub async fn get_by_connector_id(
|
|
_client_id: u64,
|
|
description: Option<String>,
|
|
) -> Option<PublicKeyBundle> {
|
|
if let Some(description) = description {
|
|
if description == "iota" {
|
|
todo!()
|
|
} else if description == "client" {
|
|
todo!()
|
|
} else if description == "anonymous" {
|
|
todo!()
|
|
} else if description == "app" {
|
|
todo!()
|
|
}
|
|
}
|
|
None
|
|
}
|
|
pub async fn complete_register(_pub_key: PublicKeyBundle, description: Option<String>) -> u64 {
|
|
if let Some(description) = description {
|
|
if description == "iota" {
|
|
todo!()
|
|
}
|
|
}
|
|
0
|
|
}
|
|
|
|
pub async fn start(port: u16) -> Result<(), Box<dyn std::error::Error>> {
|
|
let cert_pem = load_file_vec("certs", "cert.pem").expect("Error loading Pemfile");
|
|
|
|
let key_pem = load_file_vec("certs", "key.pem").expect("Error loading Keyfile");
|
|
|
|
let host_config = HostConfig::new(
|
|
IpAddr::from(Ipv4Addr::new(0, 0, 0, 0)),
|
|
port,
|
|
cert_pem,
|
|
key_pem,
|
|
)
|
|
.with_policy(Policy {
|
|
send_mode: SendMode::SingleStreamPerMessage,
|
|
max_message_size: 1_000_000_000,
|
|
close_frame_len: u32::MAX,
|
|
application_close_code: 0,
|
|
open_stream_timeout: Duration::from_millis(2_000),
|
|
write_timeout: Duration::from_millis(2_000),
|
|
accept_stream_timeout: Duration::from_millis(10_000),
|
|
read_timeout: Duration::from_millis(30_000),
|
|
keep_alive_interval: Some(Duration::from_secs(6)),
|
|
max_idle_timeout: Some(Duration::from_secs(30)),
|
|
force_close_delay: Duration::from_millis(300),
|
|
max_transient_recv_errors: 20,
|
|
transient_recv_backoff: Duration::from_millis(100),
|
|
receiver_queue_capacity: 1000,
|
|
})
|
|
.with_authentication(
|
|
load_keyring(),
|
|
Box::new(|user_id, description| Box::pin(get_by_connector_id(user_id, description))),
|
|
Box::new(|pub_key, description| Box::pin(complete_register(pub_key, description))),
|
|
)
|
|
.with_authentication_policy(AuthenticationPolicy::AllowAuthentication);
|
|
|
|
let mut host: Host = Host::new(host_config).await?;
|
|
log!(0, PrintType::General, "Server listening on port {}", port);
|
|
|
|
while let Ok(Some(conn)) = host.accept().await {
|
|
tokio::spawn(async move {
|
|
let conn = GeneralConnection::new(conn.sender, conn.receiver);
|
|
conn.handle().await;
|
|
});
|
|
}
|
|
log!(0, PrintType::General, "Server stopped");
|
|
|
|
Ok(())
|
|
}
|