mirror of
https://gitlab.com/veilid/veilid.git
synced 2024-10-01 01:26:08 -04:00
Merge branch 'main' of gitlab.hackers.town:veilid/veilid
This commit is contained in:
commit
3f7dfa6c6a
@ -13,10 +13,10 @@ rustup target add aarch64-apple-darwin aarch64-apple-ios x86_64-apple-darwin x86
|
||||
cargo install wasm-bindgen-cli
|
||||
|
||||
# install bitcode compatible ios toolchain
|
||||
echo Manual Step:
|
||||
echo install +ios-arm64-1.57.0 toolchain for bitcode from https://github.com/getditto/rust-bitcode/releases/latest and unzip
|
||||
echo xattr -d -r com.apple.quarantine .
|
||||
echo ./install.sh
|
||||
# echo Manual Step:
|
||||
# echo install +ios-arm64-1.57.0 toolchain for bitcode from https://github.com/getditto/rust-bitcode/releases/latest and unzip
|
||||
# echo xattr -d -r com.apple.quarantine .
|
||||
# echo ./install.sh
|
||||
|
||||
# ensure brew is installed
|
||||
if command -v brew &> /dev/null; then
|
||||
@ -39,8 +39,16 @@ xcode-select --install
|
||||
|
||||
# ensure packages are installed
|
||||
if [ "$BREW_USER" == "" ]; then
|
||||
BREW_USER=`ls -lad /opt/homebrew/. | cut -d\ -f4`
|
||||
echo "Must sudo to homebrew user \"$BREW_USER\" to install capnp package:"
|
||||
if [ -d /opt/homebrew ]; then
|
||||
BREW_USER=`ls -lad /opt/homebrew/. | cut -d\ -f4`
|
||||
echo "Must sudo to homebrew user \"$BREW_USER\" to install capnp package:"
|
||||
elif [ -d /usr/local/Homebrew ]; then
|
||||
BREW_USER=`ls -lad /usr/local/Homebrew/. | cut -d\ -f4`
|
||||
echo "Must sudo to homebrew user \"$BREW_USER\" to install capnp package:"
|
||||
else
|
||||
echo "Homebrew is not installed in the normal place. Trying as current user"
|
||||
BREW_USER=`whoami`
|
||||
fi
|
||||
fi
|
||||
sudo -H -u $BREW_USER brew install capnp
|
||||
|
||||
|
@ -15,8 +15,8 @@ do
|
||||
if [ "$arch" == "arm64" ]; then
|
||||
echo arm64
|
||||
CARGO_TARGET=aarch64-apple-ios
|
||||
CARGO_TOOLCHAIN=+ios-arm64-1.57.0
|
||||
#CARGO_TOOLCHAIN=
|
||||
#CARGO_TOOLCHAIN=+ios-arm64-1.57.0
|
||||
CARGO_TOOLCHAIN=
|
||||
elif [ "$arch" == "x86_64" ]; then
|
||||
echo x86_64
|
||||
CARGO_TARGET=x86_64-apple-ios
|
||||
|
@ -52,6 +52,7 @@ impl ApiTracingLayer {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip(update_callback))]
|
||||
pub async fn init(max_level: Option<VeilidLogLevel>, update_callback: UpdateCallback) {
|
||||
let api_logger = API_LOGGER.get_or_init(|| ApiTracingLayer {
|
||||
inner: Arc::new(Mutex::new(None)),
|
||||
@ -60,6 +61,7 @@ impl ApiTracingLayer {
|
||||
*api_logger.inner.lock() = apilogger_inner;
|
||||
}
|
||||
|
||||
#[instrument(level = "debug")]
|
||||
pub async fn terminate() {
|
||||
if let Some(api_logger) = API_LOGGER.get() {
|
||||
let mut inner = api_logger.inner.lock();
|
||||
@ -75,6 +77,7 @@ impl ApiTracingLayer {
|
||||
.clone()
|
||||
}
|
||||
|
||||
#[instrument(level = "trace")]
|
||||
pub fn change_api_log_level(max_level: Option<VeilidLogLevel>) {
|
||||
if let Some(api_logger) = API_LOGGER.get() {
|
||||
if let Some(inner) = &mut *api_logger.inner.lock() {
|
||||
|
@ -221,6 +221,7 @@ impl AttachmentManager {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip(self))]
|
||||
async fn attachment_maintainer(self) {
|
||||
trace!("attachment starting");
|
||||
let netman = {
|
||||
@ -229,7 +230,6 @@ impl AttachmentManager {
|
||||
inner.network_manager.clone()
|
||||
};
|
||||
|
||||
trace!("starting network");
|
||||
let mut started = true;
|
||||
if let Err(err) = netman.startup().await {
|
||||
error!("network startup failed: {}", err);
|
||||
@ -266,6 +266,7 @@ impl AttachmentManager {
|
||||
self.inner.lock().attach_timestamp = None;
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip_all, err)]
|
||||
pub async fn init(&self, update_callback: UpdateCallback) -> Result<(), String> {
|
||||
trace!("init");
|
||||
let network_manager = {
|
||||
@ -286,6 +287,8 @@ impl AttachmentManager {
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip(self))]
|
||||
pub async fn terminate(&self) {
|
||||
// Ensure we detached
|
||||
self.detach().await;
|
||||
@ -298,8 +301,8 @@ impl AttachmentManager {
|
||||
inner.update_callback = None;
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self))]
|
||||
fn attach(&self) {
|
||||
trace!("attach");
|
||||
// Create long-running connection maintenance routine
|
||||
let this = self.clone();
|
||||
self.inner.lock().maintain_peers = true;
|
||||
@ -307,8 +310,8 @@ impl AttachmentManager {
|
||||
Some(intf::spawn(this.attachment_maintainer()));
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self))]
|
||||
async fn detach(&self) {
|
||||
trace!("detach");
|
||||
let attachment_maintainer_jh = self.inner.lock().attachment_maintainer_jh.take();
|
||||
if let Some(jh) = attachment_maintainer_jh {
|
||||
// Terminate long-running connection maintenance routine
|
||||
@ -343,16 +346,18 @@ impl AttachmentManager {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), err)]
|
||||
pub async fn request_attach(&self) -> Result<(), String> {
|
||||
self.process_input(&AttachmentInput::AttachRequested)
|
||||
.await
|
||||
.map_err(|e| format!("Attach request failed: {}", e))
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), err)]
|
||||
pub async fn request_detach(&self) -> Result<(), String> {
|
||||
self.process_input(&AttachmentInput::DetachRequested)
|
||||
.await
|
||||
.map_err(|e| format!("Attach request failed: {}", e))
|
||||
.map_err(|e| format!("Detach request failed: {}", e))
|
||||
}
|
||||
|
||||
pub fn get_state(&self) -> AttachmentState {
|
||||
|
@ -10,7 +10,6 @@ cfg_if! {
|
||||
if #[cfg(target_arch = "wasm32")] {
|
||||
pub type UpdateCallback = Arc<dyn Fn(VeilidUpdate)>;
|
||||
} else {
|
||||
|
||||
pub type UpdateCallback = Arc<dyn Fn(VeilidUpdate) + Send + Sync>;
|
||||
}
|
||||
}
|
||||
@ -59,6 +58,7 @@ impl ServicesContext {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(err, skip_all)]
|
||||
pub async fn startup(&mut self) -> Result<(), VeilidAPIError> {
|
||||
let api_log_level: VeilidConfigLogLevel = self.config.get().api_log_level;
|
||||
if api_log_level != VeilidConfigLogLevel::Off {
|
||||
@ -131,6 +131,7 @@ impl ServicesContext {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[instrument(skip_all)]
|
||||
pub async fn shutdown(&mut self) {
|
||||
info!("Veilid API shutting down");
|
||||
|
||||
@ -179,6 +180,7 @@ pub struct VeilidCoreContext {
|
||||
}
|
||||
|
||||
impl VeilidCoreContext {
|
||||
#[instrument(err, skip_all)]
|
||||
async fn new_with_config_callback(
|
||||
update_callback: UpdateCallback,
|
||||
config_callback: ConfigCallback,
|
||||
@ -193,6 +195,7 @@ impl VeilidCoreContext {
|
||||
Self::new_common(update_callback, config).await
|
||||
}
|
||||
|
||||
#[instrument(err, skip(update_callback))]
|
||||
async fn new_with_config_json(
|
||||
update_callback: UpdateCallback,
|
||||
config_json: String,
|
||||
@ -206,6 +209,7 @@ impl VeilidCoreContext {
|
||||
Self::new_common(update_callback, config).await
|
||||
}
|
||||
|
||||
#[instrument(err, skip(update_callback))]
|
||||
async fn new_common(
|
||||
update_callback: UpdateCallback,
|
||||
config: VeilidConfig,
|
||||
@ -233,6 +237,7 @@ impl VeilidCoreContext {
|
||||
})
|
||||
}
|
||||
|
||||
#[instrument(skip_all)]
|
||||
async fn shutdown(self) {
|
||||
let mut sc = ServicesContext::new_full(
|
||||
self.config.clone(),
|
||||
@ -251,6 +256,7 @@ impl VeilidCoreContext {
|
||||
|
||||
static INITIALIZED: AsyncMutex<bool> = AsyncMutex::new(false);
|
||||
|
||||
#[instrument(err, skip_all)]
|
||||
pub async fn api_startup(
|
||||
update_callback: UpdateCallback,
|
||||
config_callback: ConfigCallback,
|
||||
@ -273,6 +279,7 @@ pub async fn api_startup(
|
||||
Ok(veilid_api)
|
||||
}
|
||||
|
||||
#[instrument(err, skip(update_callback))]
|
||||
pub async fn api_startup_json(
|
||||
update_callback: UpdateCallback,
|
||||
config_json: String,
|
||||
@ -294,6 +301,7 @@ pub async fn api_startup_json(
|
||||
Ok(veilid_api)
|
||||
}
|
||||
|
||||
#[instrument(skip_all)]
|
||||
pub(crate) async fn api_shutdown(context: VeilidCoreContext) {
|
||||
let mut initialized_lock = INITIALIZED.lock().await;
|
||||
context.shutdown().await;
|
||||
|
@ -29,6 +29,7 @@ impl ProtectedStore {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), err)]
|
||||
pub async fn delete_all(&self) -> Result<(), String> {
|
||||
// Delete all known keys
|
||||
if self.remove_user_secret_string("node_id").await? {
|
||||
@ -43,6 +44,7 @@ impl ProtectedStore {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip(self), err)]
|
||||
pub async fn init(&self) -> Result<(), String> {
|
||||
let delete = {
|
||||
let c = self.config.get();
|
||||
@ -95,6 +97,7 @@ impl ProtectedStore {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip(self))]
|
||||
pub async fn terminate(&self) {
|
||||
*self.inner.lock() = Self::new_inner();
|
||||
}
|
||||
@ -108,6 +111,7 @@ impl ProtectedStore {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self, value), ret, err)]
|
||||
pub async fn save_user_secret_string(&self, key: &str, value: &str) -> Result<bool, String> {
|
||||
let inner = self.inner.lock();
|
||||
inner
|
||||
@ -124,6 +128,7 @@ impl ProtectedStore {
|
||||
.map_err(logthru_pstore!())
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), err)]
|
||||
pub async fn load_user_secret_string(&self, key: &str) -> Result<Option<String>, String> {
|
||||
let inner = self.inner.lock();
|
||||
match inner
|
||||
@ -139,6 +144,7 @@ impl ProtectedStore {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), ret, err)]
|
||||
pub async fn remove_user_secret_string(&self, key: &str) -> Result<bool, String> {
|
||||
let inner = self.inner.lock();
|
||||
match inner
|
||||
@ -154,6 +160,7 @@ impl ProtectedStore {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self, value), ret, err)]
|
||||
pub async fn save_user_secret(&self, key: &str, value: &[u8]) -> Result<bool, String> {
|
||||
let mut s = BASE64URL_NOPAD.encode(value);
|
||||
s.push('!');
|
||||
@ -161,6 +168,7 @@ impl ProtectedStore {
|
||||
self.save_user_secret_string(key, s.as_str()).await
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), err)]
|
||||
pub async fn load_user_secret(&self, key: &str) -> Result<Option<Vec<u8>>, String> {
|
||||
let mut s = match self.load_user_secret_string(key).await? {
|
||||
Some(s) => s,
|
||||
@ -191,6 +199,7 @@ impl ProtectedStore {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), ret, err)]
|
||||
pub async fn remove_user_secret(&self, key: &str) -> Result<bool, String> {
|
||||
self.remove_user_secret_string(key).await
|
||||
}
|
||||
|
@ -233,6 +233,7 @@ impl NetworkManager {
|
||||
self.inner.lock().relay_node.clone()
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip_all, err)]
|
||||
pub async fn init(&self, update_callback: UpdateCallback) -> Result<(), String> {
|
||||
let routing_table = RoutingTable::new(self.clone());
|
||||
routing_table.init().await?;
|
||||
@ -240,6 +241,8 @@ impl NetworkManager {
|
||||
self.inner.lock().update_callback = Some(update_callback);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip_all)]
|
||||
pub async fn terminate(&self) {
|
||||
let routing_table = {
|
||||
let mut inner = self.inner.lock();
|
||||
@ -251,6 +254,7 @@ impl NetworkManager {
|
||||
self.inner.lock().update_callback = None;
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip_all, err)]
|
||||
pub async fn internal_startup(&self) -> Result<(), String> {
|
||||
trace!("NetworkManager::internal_startup begin");
|
||||
if self.inner.lock().components.is_some() {
|
||||
@ -281,6 +285,7 @@ impl NetworkManager {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip_all, err)]
|
||||
pub async fn startup(&self) -> Result<(), String> {
|
||||
if let Err(e) = self.internal_startup().await {
|
||||
self.shutdown().await;
|
||||
@ -292,6 +297,7 @@ impl NetworkManager {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip_all)]
|
||||
pub async fn shutdown(&self) {
|
||||
trace!("NetworkManager::shutdown begin");
|
||||
|
||||
@ -339,6 +345,7 @@ impl NetworkManager {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), ret)]
|
||||
pub fn check_client_whitelist(&self, client: DHTKey) -> bool {
|
||||
let mut inner = self.inner.lock();
|
||||
|
||||
@ -351,6 +358,7 @@ impl NetworkManager {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self))]
|
||||
pub fn purge_client_whitelist(&self) {
|
||||
let timeout_ms = self.config.get().network.client_whitelist_timeout_ms;
|
||||
let mut inner = self.inner.lock();
|
||||
@ -366,6 +374,15 @@ impl NetworkManager {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip_all, err)]
|
||||
async fn restart_net(&self, net: Network) -> Result<(), String> {
|
||||
net.shutdown().await;
|
||||
self.send_network_update();
|
||||
net.startup().await?;
|
||||
self.send_network_update();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn tick(&self) -> Result<(), String> {
|
||||
let (routing_table, net, receipt_manager) = {
|
||||
let inner = self.inner.lock();
|
||||
@ -380,10 +397,7 @@ impl NetworkManager {
|
||||
// If the network needs to be reset, do it
|
||||
// if things can't restart, then we fail out of the attachment manager
|
||||
if net.needs_restart() {
|
||||
net.shutdown().await;
|
||||
self.send_network_update();
|
||||
net.startup().await?;
|
||||
self.send_network_update();
|
||||
self.restart_net(net.clone()).await?;
|
||||
}
|
||||
|
||||
// Run the rolling transfers task
|
||||
@ -448,6 +462,7 @@ impl NetworkManager {
|
||||
}
|
||||
|
||||
// Generates a multi-shot/normal receipt
|
||||
#[instrument(level = "trace", skip(self, extra_data, callback), err)]
|
||||
pub fn generate_receipt<D: AsRef<[u8]>>(
|
||||
&self,
|
||||
expiration_us: u64,
|
||||
@ -473,6 +488,7 @@ impl NetworkManager {
|
||||
}
|
||||
|
||||
// Generates a single-shot/normal receipt
|
||||
#[instrument(level = "trace", skip(self, extra_data), err)]
|
||||
pub fn generate_single_shot_receipt<D: AsRef<[u8]>>(
|
||||
&self,
|
||||
expiration_us: u64,
|
||||
@ -498,6 +514,7 @@ impl NetworkManager {
|
||||
}
|
||||
|
||||
// Process a received out-of-band receipt
|
||||
#[instrument(level = "trace", skip(self, receipt_data), err)]
|
||||
pub async fn handle_out_of_band_receipt<R: AsRef<[u8]>>(
|
||||
&self,
|
||||
receipt_data: R,
|
||||
@ -511,6 +528,7 @@ impl NetworkManager {
|
||||
}
|
||||
|
||||
// Process a received in-band receipt
|
||||
#[instrument(level = "trace", skip(self, receipt_data), err)]
|
||||
pub async fn handle_in_band_receipt<R: AsRef<[u8]>>(
|
||||
&self,
|
||||
receipt_data: R,
|
||||
@ -527,6 +545,7 @@ impl NetworkManager {
|
||||
}
|
||||
|
||||
// Process a received signal
|
||||
#[instrument(level = "trace", skip(self), err)]
|
||||
pub async fn handle_signal(&self, signal_info: SignalInfo) -> Result<(), String> {
|
||||
match signal_info {
|
||||
SignalInfo::ReverseConnect { receipt, peer_info } => {
|
||||
@ -588,6 +607,7 @@ impl NetworkManager {
|
||||
}
|
||||
|
||||
// Builds an envelope for sending over the network
|
||||
#[instrument(level = "trace", skip(self, body), err)]
|
||||
fn build_envelope<B: AsRef<[u8]>>(
|
||||
&self,
|
||||
dest_node_id: DHTKey,
|
||||
@ -614,6 +634,7 @@ impl NetworkManager {
|
||||
// node_ref is the direct destination to which the envelope will be sent
|
||||
// If 'node_id' is specified, it can be different than node_ref.node_id()
|
||||
// which will cause the envelope to be relayed
|
||||
#[instrument(level = "trace", skip(self, body), ret, err)]
|
||||
pub async fn send_envelope<B: AsRef<[u8]>>(
|
||||
&self,
|
||||
node_ref: NodeRef,
|
||||
@ -665,6 +686,7 @@ impl NetworkManager {
|
||||
}
|
||||
|
||||
// Called by the RPC handler when we want to issue an direct receipt
|
||||
#[instrument(level = "trace", skip(self, rcpt_data), err)]
|
||||
pub async fn send_out_of_band_receipt(
|
||||
&self,
|
||||
dial_info: DialInfo,
|
||||
@ -683,6 +705,7 @@ impl NetworkManager {
|
||||
}
|
||||
|
||||
// Figure out how to reach a node
|
||||
#[instrument(level = "trace", skip(self), ret, err)]
|
||||
fn get_contact_method(&self, mut target_node_ref: NodeRef) -> Result<ContactMethod, String> {
|
||||
let routing_table = self.routing_table();
|
||||
|
||||
@ -802,6 +825,7 @@ impl NetworkManager {
|
||||
|
||||
// Send a reverse connection signal and wait for the return receipt over it
|
||||
// Then send the data across the new connection
|
||||
#[instrument(level = "trace", skip(self, data), err)]
|
||||
pub async fn do_reverse_connect(
|
||||
&self,
|
||||
relay_nr: NodeRef,
|
||||
@ -872,6 +896,7 @@ impl NetworkManager {
|
||||
|
||||
// Send a hole punch signal and do a negotiating ping and wait for the return receipt
|
||||
// Then send the data across the new connection
|
||||
#[instrument(level = "trace", skip(self, data), err)]
|
||||
pub async fn do_hole_punch(
|
||||
&self,
|
||||
relay_nr: NodeRef,
|
||||
@ -1036,6 +1061,7 @@ impl NetworkManager {
|
||||
// Called when a packet potentially containing an RPC envelope is received by a low-level
|
||||
// network protocol handler. Processes the envelope, authenticates and decrypts the RPC message
|
||||
// and passes it to the RPC handler
|
||||
#[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
|
||||
async fn on_recv_envelope(
|
||||
&self,
|
||||
data: &[u8],
|
||||
@ -1175,6 +1201,7 @@ impl NetworkManager {
|
||||
}
|
||||
|
||||
// Keep relays assigned and accessible
|
||||
#[instrument(level = "trace", skip(self), err)]
|
||||
async fn relay_management_task_routine(self, _last_ts: u64, cur_ts: u64) -> Result<(), String> {
|
||||
// log_net!("--- network manager relay_management task");
|
||||
|
||||
@ -1227,6 +1254,7 @@ impl NetworkManager {
|
||||
}
|
||||
|
||||
// Compute transfer statistics for the low level network
|
||||
#[instrument(level = "trace", skip(self), err)]
|
||||
async fn rolling_transfers_task_routine(self, last_ts: u64, cur_ts: u64) -> Result<(), String> {
|
||||
// log_net!("--- network manager rolling_transfers task");
|
||||
{
|
||||
|
@ -267,6 +267,7 @@ impl Network {
|
||||
// This creates a short-lived connection in the case of connection-oriented protocols
|
||||
// for the purpose of sending this one message.
|
||||
// This bypasses the connection table as it is not a 'node to node' connection.
|
||||
#[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
|
||||
pub async fn send_data_unbound_to_dial_info(
|
||||
&self,
|
||||
dial_info: DialInfo,
|
||||
@ -300,6 +301,7 @@ impl Network {
|
||||
res
|
||||
}
|
||||
|
||||
#[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
|
||||
pub async fn send_data_to_existing_connection(
|
||||
&self,
|
||||
descriptor: ConnectionDescriptor,
|
||||
@ -357,6 +359,7 @@ impl Network {
|
||||
}
|
||||
|
||||
// Send data directly to a dial info, possibly without knowing which node it is going to
|
||||
#[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
|
||||
pub async fn send_data_to_dial_info(
|
||||
&self,
|
||||
dial_info: DialInfo,
|
||||
@ -404,9 +407,8 @@ impl Network {
|
||||
self.inner.lock().protocol_config
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", err, skip_all)]
|
||||
pub async fn startup(&self) -> Result<(), String> {
|
||||
trace!("startup network");
|
||||
|
||||
// initialize interfaces
|
||||
let mut interfaces = NetworkInterfaces::new();
|
||||
interfaces.refresh().await?;
|
||||
@ -492,10 +494,12 @@ impl Network {
|
||||
self.inner.lock().network_started
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip_all)]
|
||||
pub fn restart_network(&self) {
|
||||
self.inner.lock().network_needs_restart = true;
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip_all)]
|
||||
pub async fn shutdown(&self) {
|
||||
info!("stopping network");
|
||||
|
||||
@ -524,6 +528,7 @@ impl Network {
|
||||
inner.network_class
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip_all)]
|
||||
pub fn reset_network_class(&self) {
|
||||
let mut inner = self.inner.lock();
|
||||
inner.network_class = None;
|
||||
|
@ -51,30 +51,30 @@ impl DiscoveryContext {
|
||||
// Pick the best network class we have seen so far
|
||||
pub fn set_detected_network_class(&self, network_class: NetworkClass) {
|
||||
let mut inner = self.inner.lock();
|
||||
log_net!( debug
|
||||
"=== set_detected_network_class {:?} {:?}: {:?} ===",
|
||||
inner.protocol_type,
|
||||
inner.address_type,
|
||||
network_class
|
||||
debug!(target: "net",
|
||||
protocol_type=?inner.protocol_type,
|
||||
address_type=?inner.address_type,
|
||||
?network_class,
|
||||
"set_detected_network_class"
|
||||
);
|
||||
|
||||
inner.detected_network_class = Some(network_class);
|
||||
}
|
||||
|
||||
pub fn set_detected_public_dial_info(&self, dial_info: DialInfo, class: DialInfoClass) {
|
||||
let mut inner = self.inner.lock();
|
||||
log_net!( debug
|
||||
"=== set_detected_public_dial_info {:?} {:?}: {} {:?} ===",
|
||||
inner.protocol_type,
|
||||
inner.address_type,
|
||||
dial_info,
|
||||
class
|
||||
debug!(target: "net",
|
||||
protocol_type=?inner.protocol_type,
|
||||
address_type=?inner.address_type,
|
||||
?dial_info,
|
||||
?class,
|
||||
"set_detected_public_dial_info"
|
||||
);
|
||||
inner.detected_public_dial_info = Some(DetectedPublicDialInfo { dial_info, class });
|
||||
}
|
||||
|
||||
// Ask for a public address check from a particular noderef
|
||||
// This is done over the normal port using RPC
|
||||
#[instrument(level = "trace", skip(self), ret)]
|
||||
async fn request_public_address(&self, node_ref: NodeRef) -> Option<SocketAddress> {
|
||||
let rpc = self.routing_table.rpc_processor();
|
||||
rpc.rpc_call_status(node_ref.clone())
|
||||
@ -93,6 +93,7 @@ impl DiscoveryContext {
|
||||
|
||||
// find fast peers with a particular address type, and ask them to tell us what our external address is
|
||||
// This is done over the normal port using RPC
|
||||
#[instrument(level = "trace", skip(self), ret)]
|
||||
async fn discover_external_address(
|
||||
&self,
|
||||
protocol_type: ProtocolType,
|
||||
@ -122,6 +123,7 @@ impl DiscoveryContext {
|
||||
}
|
||||
|
||||
// This pulls the already-detected local interface dial info from the routing table
|
||||
#[instrument(level = "trace", skip(self), ret)]
|
||||
fn get_local_addresses(
|
||||
&self,
|
||||
protocol_type: ProtocolType,
|
||||
@ -143,6 +145,7 @@ impl DiscoveryContext {
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), ret)]
|
||||
async fn validate_dial_info(
|
||||
&self,
|
||||
node_ref: NodeRef,
|
||||
@ -165,6 +168,7 @@ impl DiscoveryContext {
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), ret)]
|
||||
async fn try_port_mapping(&self) -> Option<DialInfo> {
|
||||
//xxx
|
||||
None
|
||||
@ -189,6 +193,7 @@ impl DiscoveryContext {
|
||||
///////
|
||||
// Per-protocol discovery routines
|
||||
|
||||
#[instrument(level = "trace", skip(self))]
|
||||
pub fn protocol_begin(&self, protocol_type: ProtocolType, address_type: AddressType) {
|
||||
// Get our interface addresses
|
||||
let intf_addrs = self.get_local_addresses(protocol_type, address_type);
|
||||
@ -203,6 +208,7 @@ impl DiscoveryContext {
|
||||
}
|
||||
|
||||
// Get our first node's view of our external IP address via normal RPC
|
||||
#[instrument(level = "trace", skip(self), ret)]
|
||||
pub async fn protocol_get_external_address_1(&self) -> bool {
|
||||
let (protocol_type, address_type) = {
|
||||
let inner = self.inner.lock();
|
||||
@ -234,6 +240,7 @@ impl DiscoveryContext {
|
||||
}
|
||||
|
||||
// If we know we are not behind NAT, check our firewall status
|
||||
#[instrument(level = "trace", skip(self), err)]
|
||||
pub async fn protocol_process_no_nat(&self) -> Result<(), String> {
|
||||
let (node_1, external_1_dial_info) = {
|
||||
let inner = self.inner.lock();
|
||||
@ -264,6 +271,7 @@ impl DiscoveryContext {
|
||||
}
|
||||
|
||||
// If we know we are behind NAT check what kind
|
||||
#[instrument(level = "trace", skip(self), ret, err)]
|
||||
pub async fn protocol_process_nat(&self) -> Result<bool, String> {
|
||||
let (node_1, external_1_dial_info, external_1_address, protocol_type, address_type) = {
|
||||
let inner = self.inner.lock();
|
||||
@ -353,6 +361,7 @@ impl DiscoveryContext {
|
||||
}
|
||||
|
||||
impl Network {
|
||||
#[instrument(level = "trace", skip(self, context), err)]
|
||||
pub async fn update_ipv4_protocol_dialinfo(
|
||||
&self,
|
||||
context: &DiscoveryContext,
|
||||
@ -414,6 +423,7 @@ impl Network {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self, context), err)]
|
||||
pub async fn update_ipv6_protocol_dialinfo(
|
||||
&self,
|
||||
context: &DiscoveryContext,
|
||||
@ -454,9 +464,8 @@ impl Network {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), err)]
|
||||
pub async fn update_network_class_task_routine(self, _l: u64, _t: u64) -> Result<(), String> {
|
||||
log_net!("--- updating network class");
|
||||
|
||||
// Ensure we aren't trying to update this without clearing it first
|
||||
let old_network_class = self.inner.lock().network_class;
|
||||
assert_eq!(old_network_class, None);
|
||||
|
@ -51,6 +51,7 @@ impl Network {
|
||||
|
||||
/////////////////////////////////////////////////////////////////
|
||||
|
||||
#[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
|
||||
pub async fn send_data_unbound_to_dial_info(
|
||||
&self,
|
||||
dial_info: DialInfo,
|
||||
@ -79,6 +80,7 @@ impl Network {
|
||||
res
|
||||
}
|
||||
|
||||
#[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
|
||||
pub async fn send_data_to_existing_connection(
|
||||
&self,
|
||||
descriptor: ConnectionDescriptor,
|
||||
@ -115,6 +117,7 @@ impl Network {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level="trace", err, skip(self, data), fields(data.len = data.len()))]
|
||||
pub async fn send_data_to_dial_info(
|
||||
&self,
|
||||
dial_info: DialInfo,
|
||||
|
@ -234,6 +234,7 @@ impl ReceiptManager {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self))]
|
||||
pub async fn timeout_task_routine(self, now: u64) {
|
||||
// Go through all receipts and build a list of expired nonces
|
||||
let mut new_next_oldest_ts: Option<u64> = None;
|
||||
|
@ -730,6 +730,7 @@ impl RoutingTable {
|
||||
best_inbound_relay.map(|(k, e)| NodeRef::new(self.clone(), *k, e, None))
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), ret, err)]
|
||||
pub fn register_find_node_answer(&self, fna: FindNodeAnswer) -> Result<Vec<NodeRef>, String> {
|
||||
let node_id = self.node_id();
|
||||
|
||||
@ -755,6 +756,7 @@ impl RoutingTable {
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), ret, err)]
|
||||
pub async fn find_node(
|
||||
&self,
|
||||
node_ref: NodeRef,
|
||||
@ -773,26 +775,24 @@ impl RoutingTable {
|
||||
.await
|
||||
.map_err(map_to_string)
|
||||
.map_err(logthru_rtab!())?;
|
||||
log_rtab!(
|
||||
"find_self for at {:?} answered in {}ms",
|
||||
&node_ref,
|
||||
timestamp_to_secs(res.latency) * 1000.0f64
|
||||
);
|
||||
|
||||
// register nodes we'd found
|
||||
self.register_find_node_answer(res)
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), ret, err)]
|
||||
pub async fn find_self(&self, node_ref: NodeRef) -> Result<Vec<NodeRef>, String> {
|
||||
let node_id = self.node_id();
|
||||
self.find_node(node_ref, node_id).await
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), ret, err)]
|
||||
pub async fn find_target(&self, node_ref: NodeRef) -> Result<Vec<NodeRef>, String> {
|
||||
let node_id = node_ref.node_id();
|
||||
self.find_node(node_ref, node_id).await
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self))]
|
||||
pub async fn reverse_find_node(&self, node_ref: NodeRef, wide: bool) {
|
||||
// Ask bootstrap node to 'find' our own node so we can get some more nodes near ourselves
|
||||
// and then contact those nodes to inform -them- that we exist
|
||||
@ -827,6 +827,7 @@ impl RoutingTable {
|
||||
}
|
||||
|
||||
// Bootstrap lookup process
|
||||
#[instrument(level = "trace", skip(self), ret, err)]
|
||||
async fn resolve_bootstrap(
|
||||
&self,
|
||||
bootstrap: Vec<String>,
|
||||
@ -990,6 +991,7 @@ impl RoutingTable {
|
||||
Ok(bsmap)
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self), err)]
|
||||
async fn bootstrap_task_routine(self) -> Result<(), String> {
|
||||
let (bootstrap, bootstrap_nodes) = {
|
||||
let c = self.config.get();
|
||||
@ -1092,9 +1094,8 @@ impl RoutingTable {
|
||||
|
||||
// Ask our remaining peers to give us more peers before we go
|
||||
// back to the bootstrap servers to keep us from bothering them too much
|
||||
#[instrument(level = "trace", skip(self), err)]
|
||||
async fn peer_minimum_refresh_task_routine(self) -> Result<(), String> {
|
||||
// log_rtab!("--- peer_minimum_refresh task");
|
||||
|
||||
// get list of all peers we know about, even the unreliable ones, and ask them to find nodes close to our node too
|
||||
let noderefs = {
|
||||
let mut inner = self.inner.lock();
|
||||
@ -1125,6 +1126,7 @@ impl RoutingTable {
|
||||
|
||||
// Ping each node in the routing table if they need to be pinged
|
||||
// to determine their reliability
|
||||
#[instrument(level = "trace", skip(self), err)]
|
||||
async fn ping_validator_task_routine(self, _last_ts: u64, cur_ts: u64) -> Result<(), String> {
|
||||
// log_rtab!("--- ping_validator task");
|
||||
|
||||
@ -1149,6 +1151,7 @@ impl RoutingTable {
|
||||
}
|
||||
|
||||
// Compute transfer statistics to determine how 'fast' a node is
|
||||
#[instrument(level = "trace", skip(self), err)]
|
||||
async fn rolling_transfers_task_routine(self, last_ts: u64, cur_ts: u64) -> Result<(), String> {
|
||||
// log_rtab!("--- rolling_transfers task");
|
||||
let inner = &mut *self.inner.lock();
|
||||
|
@ -1742,6 +1742,7 @@ pub struct VeilidAPI {
|
||||
}
|
||||
|
||||
impl VeilidAPI {
|
||||
#[instrument(skip_all)]
|
||||
pub(crate) fn new(context: VeilidCoreContext) -> Self {
|
||||
Self {
|
||||
inner: Arc::new(Mutex::new(VeilidAPIInner {
|
||||
@ -1750,6 +1751,7 @@ impl VeilidAPI {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(skip_all)]
|
||||
pub async fn shutdown(self) {
|
||||
let context = { self.inner.lock().context.take() };
|
||||
if let Some(context) = context {
|
||||
@ -1840,6 +1842,7 @@ impl VeilidAPI {
|
||||
// get network connectedness
|
||||
|
||||
// connect to the network
|
||||
#[instrument(level = "debug", err, skip_all)]
|
||||
pub async fn attach(&self) -> Result<(), VeilidAPIError> {
|
||||
let attachment_manager = self.attachment_manager()?;
|
||||
attachment_manager
|
||||
@ -1849,6 +1852,7 @@ impl VeilidAPI {
|
||||
}
|
||||
|
||||
// disconnect from the network
|
||||
#[instrument(level = "debug", err, skip_all)]
|
||||
pub async fn detach(&self) -> Result<(), VeilidAPIError> {
|
||||
let attachment_manager = self.attachment_manager()?;
|
||||
attachment_manager
|
||||
@ -1858,6 +1862,7 @@ impl VeilidAPI {
|
||||
}
|
||||
|
||||
// Change api logging level if it is enabled
|
||||
#[instrument(skip(self))]
|
||||
pub async fn change_api_log_level(&self, log_level: VeilidConfigLogLevel) {
|
||||
ApiTracingLayer::change_api_log_level(log_level.to_veilid_log_level());
|
||||
}
|
||||
@ -1865,6 +1870,7 @@ impl VeilidAPI {
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Direct Node Access (pretty much for testing only)
|
||||
|
||||
#[instrument(level = "debug", err, skip(self))]
|
||||
pub async fn status(&self, node_id: NodeId) -> Result<StatusAnswer, VeilidAPIError> {
|
||||
let rpc = self.rpc_processor()?;
|
||||
let routing_table = rpc.routing_table();
|
||||
@ -1879,6 +1885,7 @@ impl VeilidAPI {
|
||||
Ok(status_answer)
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", err, skip(self))]
|
||||
pub async fn validate_dial_info(
|
||||
&self,
|
||||
node_id: NodeId,
|
||||
@ -1896,6 +1903,7 @@ impl VeilidAPI {
|
||||
.map_err(map_rpc_error!())
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", err, skip(self))]
|
||||
pub async fn search_dht(&self, node_id: NodeId) -> Result<PeerInfo, VeilidAPIError> {
|
||||
let rpc_processor = self.rpc_processor()?;
|
||||
let config = self.config()?;
|
||||
@ -1923,6 +1931,7 @@ impl VeilidAPI {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", err, skip(self))]
|
||||
pub async fn search_dht_multi(&self, node_id: NodeId) -> Result<Vec<PeerInfo>, VeilidAPIError> {
|
||||
let rpc_processor = self.rpc_processor()?;
|
||||
let config = self.config()?;
|
||||
@ -1948,6 +1957,7 @@ impl VeilidAPI {
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Safety / Private Route Handling
|
||||
|
||||
#[instrument(level = "debug", err, skip(self))]
|
||||
pub async fn new_safety_route_spec(
|
||||
&self,
|
||||
_hops: u8,
|
||||
@ -1955,6 +1965,7 @@ impl VeilidAPI {
|
||||
panic!("unimplemented");
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", err, skip(self))]
|
||||
pub async fn new_private_route_spec(
|
||||
&self,
|
||||
_hops: u8,
|
||||
@ -1968,6 +1979,7 @@ impl VeilidAPI {
|
||||
// Safety route specified here is for _this_ node's anonymity as a sender, used via the 'route' operation
|
||||
// Private route specified here is for _this_ node's anonymity as a receiver, passed out via the 'respond_to' field for replies
|
||||
|
||||
#[instrument(skip(self))]
|
||||
pub async fn safe_private(
|
||||
&self,
|
||||
safety_route_spec: SafetyRouteSpec,
|
||||
@ -1980,6 +1992,7 @@ impl VeilidAPI {
|
||||
.await
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip(self))]
|
||||
pub async fn safe_public(&self, safety_route_spec: SafetyRouteSpec) -> RoutingContext {
|
||||
self.routing_context(RoutingContextOptions {
|
||||
safety_route_spec: Some(safety_route_spec),
|
||||
@ -1988,6 +2001,7 @@ impl VeilidAPI {
|
||||
.await
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip(self))]
|
||||
pub async fn unsafe_private(&self, private_route_spec: PrivateRouteSpec) -> RoutingContext {
|
||||
self.routing_context(RoutingContextOptions {
|
||||
safety_route_spec: None,
|
||||
@ -1996,6 +2010,7 @@ impl VeilidAPI {
|
||||
.await
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip(self))]
|
||||
pub async fn unsafe_public(&self) -> RoutingContext {
|
||||
self.routing_context(RoutingContextOptions {
|
||||
safety_route_spec: None,
|
||||
@ -2003,6 +2018,8 @@ impl VeilidAPI {
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip(self))]
|
||||
pub async fn routing_context(&self, options: RoutingContextOptions) -> RoutingContext {
|
||||
RoutingContext::new(self.clone(), options)
|
||||
}
|
||||
@ -2010,6 +2027,7 @@ impl VeilidAPI {
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Tunnel Building
|
||||
|
||||
#[instrument(level = "debug", err, skip(self))]
|
||||
pub async fn start_tunnel(
|
||||
&self,
|
||||
_endpoint_mode: TunnelMode,
|
||||
@ -2018,6 +2036,7 @@ impl VeilidAPI {
|
||||
panic!("unimplemented");
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", err, skip(self))]
|
||||
pub async fn complete_tunnel(
|
||||
&self,
|
||||
_endpoint_mode: TunnelMode,
|
||||
@ -2027,6 +2046,7 @@ impl VeilidAPI {
|
||||
panic!("unimplemented");
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", err, skip(self))]
|
||||
pub async fn cancel_tunnel(&self, _tunnel_id: TunnelId) -> Result<bool, VeilidAPIError> {
|
||||
panic!("unimplemented");
|
||||
}
|
||||
|
@ -1,24 +1,40 @@
|
||||
use super::*;
|
||||
use core::fmt::Debug;
|
||||
|
||||
pub fn deserialize_json<'a, T: de::Deserialize<'a>>(
|
||||
#[instrument(level = "trace", ret, err)]
|
||||
pub fn deserialize_json<'a, T: de::Deserialize<'a> + Debug>(
|
||||
arg: &'a str,
|
||||
) -> Result<T, super::VeilidAPIError> {
|
||||
) -> Result<T, VeilidAPIError> {
|
||||
serde_json::from_str(arg).map_err(|e| VeilidAPIError::ParseError {
|
||||
message: e.to_string(),
|
||||
value: String::new(),
|
||||
value: format!(
|
||||
"deserialize_json:\n---\n{}\n---\n to type {}",
|
||||
arg,
|
||||
std::any::type_name::<T>()
|
||||
),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn deserialize_opt_json<T: de::DeserializeOwned>(
|
||||
#[instrument(level = "trace", ret, err)]
|
||||
pub fn deserialize_opt_json<T: de::DeserializeOwned + Debug>(
|
||||
arg: Option<String>,
|
||||
) -> Result<T, VeilidAPIError> {
|
||||
let arg = arg.ok_or_else(|| VeilidAPIError::ParseError {
|
||||
let arg = arg.as_ref().ok_or_else(|| VeilidAPIError::ParseError {
|
||||
message: "invalid null string".to_owned(),
|
||||
value: String::new(),
|
||||
value: format!(
|
||||
"deserialize_json_opt: null to type {}",
|
||||
std::any::type_name::<T>()
|
||||
),
|
||||
})?;
|
||||
deserialize_json(&arg)
|
||||
deserialize_json(arg)
|
||||
}
|
||||
|
||||
pub fn serialize_json<T: Serialize>(val: T) -> String {
|
||||
serde_json::to_string(&val).expect("failed to serialize json value")
|
||||
#[instrument(level = "trace", ret)]
|
||||
pub fn serialize_json<T: Serialize + Debug>(val: T) -> String {
|
||||
match serde_json::to_string(&val) {
|
||||
Ok(v) => v,
|
||||
Err(e) => {
|
||||
panic!("failed to serialize json value: {}\nval={:?}", e, val);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -237,6 +237,15 @@ pub struct VeilidConfig {
|
||||
inner: Arc<RwLock<VeilidConfigInner>>,
|
||||
}
|
||||
|
||||
impl fmt::Debug for VeilidConfig {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
let inner = self.inner.read();
|
||||
f.debug_struct("VeilidConfig")
|
||||
.field("inner", &*inner)
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for VeilidConfig {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
|
@ -7,7 +7,7 @@ Future<VeilidConfig> getDefaultVeilidConfig() async {
|
||||
return VeilidConfig(
|
||||
programName: "Veilid Plugin Test",
|
||||
namespace: "",
|
||||
logLevel: VeilidConfigLogLevel.info,
|
||||
apiLogLevel: VeilidConfigLogLevel.info,
|
||||
capabilities: VeilidConfigCapabilities(
|
||||
protocolUDP: !kIsWeb,
|
||||
protocolConnectTCP: !kIsWeb,
|
||||
|
@ -36,8 +36,28 @@ LogOptions getLogOptions(LogLevel? level) {
|
||||
);
|
||||
}
|
||||
|
||||
VeilidConfigLogLevel convertToVeilidConfigLogLevel(LogLevel? level) {
|
||||
if (level == null) {
|
||||
return VeilidConfigLogLevel.off;
|
||||
}
|
||||
switch (level) {
|
||||
case LogLevel.error:
|
||||
return VeilidConfigLogLevel.error;
|
||||
case LogLevel.warning:
|
||||
return VeilidConfigLogLevel.warn;
|
||||
case LogLevel.info:
|
||||
return VeilidConfigLogLevel.info;
|
||||
case LogLevel.debug:
|
||||
return VeilidConfigLogLevel.debug;
|
||||
case traceLevel:
|
||||
return VeilidConfigLogLevel.trace;
|
||||
}
|
||||
return VeilidConfigLogLevel.off;
|
||||
}
|
||||
|
||||
void setRootLogLevel(LogLevel? level) {
|
||||
Loggy('').level = getLogOptions(level);
|
||||
Veilid.instance.changeApiLogLevel(convertToVeilidConfigLogLevel(level));
|
||||
}
|
||||
|
||||
void initLoggy() {
|
||||
@ -138,7 +158,7 @@ class _MyAppState extends State<MyApp> with UiLoggy {
|
||||
if (update is VeilidUpdateLog) {
|
||||
await processUpdateLog(update);
|
||||
} else {
|
||||
loggy.trace("Update: " + update.toString());
|
||||
loggy.trace("Update: " + update.json.toString());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -6,6 +6,9 @@ list(APPEND FLUTTER_PLUGIN_LIST
|
||||
veilid
|
||||
)
|
||||
|
||||
list(APPEND FLUTTER_FFI_PLUGIN_LIST
|
||||
)
|
||||
|
||||
set(PLUGIN_BUNDLED_LIBRARIES)
|
||||
|
||||
foreach(plugin ${FLUTTER_PLUGIN_LIST})
|
||||
@ -14,3 +17,8 @@ foreach(plugin ${FLUTTER_PLUGIN_LIST})
|
||||
list(APPEND PLUGIN_BUNDLED_LIBRARIES $<TARGET_FILE:${plugin}_plugin>)
|
||||
list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries})
|
||||
endforeach(plugin)
|
||||
|
||||
foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST})
|
||||
add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/linux plugins/${ffi_plugin})
|
||||
list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries})
|
||||
endforeach(ffi_plugin)
|
||||
|
@ -21,8 +21,8 @@ EXTERNAL SOURCES:
|
||||
SPEC CHECKSUMS:
|
||||
FlutterMacOS: 57701585bf7de1b3fc2bb61f6378d73bbdea8424
|
||||
path_provider_macos: 160cab0d5461f0c0e02995469a98f24bdb9a3f1f
|
||||
veilid: f6b04d095ac7058ddf9c00215eb2699de8cc4673
|
||||
veilid: 6bed3adec63fd8708a2ace498e0e17941c9fc32b
|
||||
|
||||
PODFILE CHECKSUM: 6eac6b3292e5142cfc23bdeb71848a40ec51c14c
|
||||
|
||||
COCOAPODS: 1.11.2
|
||||
COCOAPODS: 1.11.3
|
||||
|
@ -49,7 +49,7 @@ packages:
|
||||
name: collection
|
||||
url: "https://pub.dartlang.org"
|
||||
source: hosted
|
||||
version: "1.15.0"
|
||||
version: "1.16.0"
|
||||
cupertino_icons:
|
||||
dependency: "direct main"
|
||||
description:
|
||||
@ -63,7 +63,7 @@ packages:
|
||||
name: fake_async
|
||||
url: "https://pub.dartlang.org"
|
||||
source: hosted
|
||||
version: "1.2.0"
|
||||
version: "1.3.0"
|
||||
ffi:
|
||||
dependency: transitive
|
||||
description:
|
||||
@ -113,7 +113,7 @@ packages:
|
||||
name: js
|
||||
url: "https://pub.dartlang.org"
|
||||
source: hosted
|
||||
version: "0.6.3"
|
||||
version: "0.6.4"
|
||||
lints:
|
||||
dependency: transitive
|
||||
description:
|
||||
@ -141,7 +141,7 @@ packages:
|
||||
name: material_color_utilities
|
||||
url: "https://pub.dartlang.org"
|
||||
source: hosted
|
||||
version: "0.1.3"
|
||||
version: "0.1.4"
|
||||
meta:
|
||||
dependency: transitive
|
||||
description:
|
||||
@ -155,7 +155,7 @@ packages:
|
||||
name: path
|
||||
url: "https://pub.dartlang.org"
|
||||
source: hosted
|
||||
version: "1.8.0"
|
||||
version: "1.8.1"
|
||||
path_provider:
|
||||
dependency: transitive
|
||||
description:
|
||||
@ -244,7 +244,7 @@ packages:
|
||||
name: source_span
|
||||
url: "https://pub.dartlang.org"
|
||||
source: hosted
|
||||
version: "1.8.1"
|
||||
version: "1.8.2"
|
||||
stack_trace:
|
||||
dependency: transitive
|
||||
description:
|
||||
@ -279,21 +279,14 @@ packages:
|
||||
name: test_api
|
||||
url: "https://pub.dartlang.org"
|
||||
source: hosted
|
||||
version: "0.4.8"
|
||||
typed_data:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: typed_data
|
||||
url: "https://pub.dartlang.org"
|
||||
source: hosted
|
||||
version: "1.3.0"
|
||||
version: "0.4.9"
|
||||
vector_math:
|
||||
dependency: transitive
|
||||
description:
|
||||
name: vector_math
|
||||
url: "https://pub.dartlang.org"
|
||||
source: hosted
|
||||
version: "2.1.1"
|
||||
version: "2.1.2"
|
||||
veilid:
|
||||
dependency: "direct main"
|
||||
description:
|
||||
@ -316,5 +309,5 @@ packages:
|
||||
source: hosted
|
||||
version: "0.2.0+1"
|
||||
sdks:
|
||||
dart: ">=2.16.1 <3.0.0"
|
||||
dart: ">=2.17.0-0 <3.0.0"
|
||||
flutter: ">=2.8.0"
|
||||
|
@ -6,6 +6,9 @@ list(APPEND FLUTTER_PLUGIN_LIST
|
||||
veilid
|
||||
)
|
||||
|
||||
list(APPEND FLUTTER_FFI_PLUGIN_LIST
|
||||
)
|
||||
|
||||
set(PLUGIN_BUNDLED_LIBRARIES)
|
||||
|
||||
foreach(plugin ${FLUTTER_PLUGIN_LIST})
|
||||
@ -14,3 +17,8 @@ foreach(plugin ${FLUTTER_PLUGIN_LIST})
|
||||
list(APPEND PLUGIN_BUNDLED_LIBRARIES $<TARGET_FILE:${plugin}_plugin>)
|
||||
list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries})
|
||||
endforeach(plugin)
|
||||
|
||||
foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST})
|
||||
add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/windows plugins/${ffi_plugin})
|
||||
list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries})
|
||||
endforeach(ffi_plugin)
|
||||
|
@ -33,8 +33,8 @@ Veilid Network Plugin
|
||||
s.script_phase = {
|
||||
:name => 'Cargo Build',
|
||||
:script => File.join(File.dirname(__dir__), 'rust', 'ios_build.sh'),
|
||||
:execution_position => :before_compile,
|
||||
:output_files => [ File.join(cargo_target_dir, 'ios_lib', 'libveilid_flutter.a') ]
|
||||
:execution_position => :before_compile
|
||||
# :output_files => [ File.join(cargo_target_dir, 'ios_lib', 'libveilid_flutter.a') ]
|
||||
}
|
||||
|
||||
end
|
||||
|
@ -815,6 +815,7 @@ abstract class VeilidUpdate {
|
||||
}
|
||||
}
|
||||
}
|
||||
Map<String, dynamic> get json;
|
||||
}
|
||||
|
||||
class VeilidUpdateLog implements VeilidUpdate {
|
||||
@ -822,12 +823,29 @@ class VeilidUpdateLog implements VeilidUpdate {
|
||||
final String message;
|
||||
//
|
||||
VeilidUpdateLog(this.logLevel, this.message);
|
||||
|
||||
@override
|
||||
Map<String, dynamic> get json {
|
||||
return {
|
||||
'kind': "Log",
|
||||
'log_level': logLevel.json,
|
||||
'message': message,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
class VeilidUpdateAttachment implements VeilidUpdate {
|
||||
final AttachmentState state;
|
||||
//
|
||||
VeilidUpdateAttachment(this.state);
|
||||
|
||||
@override
|
||||
Map<String, dynamic> get json {
|
||||
return {
|
||||
'kind': "Attachment",
|
||||
'state': state.json,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
class VeilidUpdateNetwork implements VeilidUpdate {
|
||||
@ -836,6 +854,16 @@ class VeilidUpdateNetwork implements VeilidUpdate {
|
||||
final int bpsUp;
|
||||
//
|
||||
VeilidUpdateNetwork(this.started, this.bpsDown, this.bpsUp);
|
||||
|
||||
@override
|
||||
Map<String, dynamic> get json {
|
||||
return {
|
||||
'kind': "Network",
|
||||
'started': started,
|
||||
'bps_down': bpsDown,
|
||||
'bps_up': bpsUp
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////
|
||||
|
@ -300,7 +300,9 @@ class VeilidFFI implements Veilid {
|
||||
|
||||
@override
|
||||
Future<void> changeApiLogLevel(VeilidConfigLogLevel logLevel) async {
|
||||
var nativeLogLevel = logLevel.json.toNativeUtf8();
|
||||
var nativeLogLevel =
|
||||
jsonEncode(logLevel.json, toEncodable: veilidApiToEncodable)
|
||||
.toNativeUtf8();
|
||||
final recvPort = ReceivePort("change_api_log_level");
|
||||
final sendPort = recvPort.sendPort;
|
||||
_changeApiLogLevel(sendPort.nativePort, nativeLogLevel);
|
||||
|
@ -27,8 +27,8 @@ Veilid Network Plugin
|
||||
s.script_phase = {
|
||||
:name => 'Cargo Build',
|
||||
:script => File.join(File.dirname(__dir__), 'rust', 'macos_build.sh'),
|
||||
:execution_position => :before_compile,
|
||||
:output_files => [ File.join(cargo_target_dir, 'macos_lib', 'libveilid_flutter.dylib') ]
|
||||
:execution_position => :before_compile
|
||||
#:output_files => [ File.join(cargo_target_dir, 'macos_lib', 'libveilid_flutter.dylib') ]
|
||||
}
|
||||
|
||||
end
|
||||
|
@ -1,11 +1,13 @@
|
||||
#!/bin/bash
|
||||
set -e
|
||||
echo Running veilid-flutter rust iOS build script
|
||||
|
||||
# Setup varaiables
|
||||
SCRIPTDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
|
||||
FLUTTER_DIR=$(dirname `which flutter`)
|
||||
HOMEBREW_DIR=$(dirname `which brew`)
|
||||
CARGO_DIR=$(dirname `which cargo`)
|
||||
CARGO_MANIFEST_PATH=$(python -c "import os; print(os.path.realpath(\"$SCRIPTDIR/Cargo.toml\"))")
|
||||
CARGO_MANIFEST_PATH=$(python3 -c "import os; print(os.path.realpath(\"$SCRIPTDIR/Cargo.toml\"))")
|
||||
TARGET_DIR=$(dirname `cargo locate-project --message-format plain`)/target
|
||||
|
||||
# Configure outputs
|
||||
@ -30,7 +32,8 @@ do
|
||||
if [ "$arch" == "arm64" ]; then
|
||||
echo arm64
|
||||
CARGO_TARGET=aarch64-apple-ios
|
||||
CARGO_TOOLCHAIN=+ios-arm64-1.57.0
|
||||
#CARGO_TOOLCHAIN=+ios-arm64-1.57.0
|
||||
CARGO_TOOLCHAIN=
|
||||
elif [ "$arch" == "x86_64" ]; then
|
||||
echo x86_64
|
||||
CARGO_TARGET=x86_64-apple-ios
|
||||
|
@ -1,11 +1,13 @@
|
||||
#!/bin/bash
|
||||
set -e
|
||||
echo Running veilid-flutter rust MacOS build script
|
||||
|
||||
# Setup varaiables
|
||||
SCRIPTDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
|
||||
FLUTTER_DIR=$(dirname `which flutter`)
|
||||
HOMEBREW_DIR=$(dirname `which brew`)
|
||||
CARGO_DIR=$(dirname `which cargo`)
|
||||
CARGO_MANIFEST_PATH=$(python -c "import os; print(os.path.realpath(\"$SCRIPTDIR/Cargo.toml\"))")
|
||||
CARGO_MANIFEST_PATH=$(python3 -c "import os; print(os.path.realpath(\"$SCRIPTDIR/Cargo.toml\"))")
|
||||
TARGET_DIR=$(dirname `cargo locate-project --message-format plain`)/target
|
||||
|
||||
# Configure outputs
|
||||
|
@ -54,6 +54,7 @@ macro_rules! check_err_json {
|
||||
/////////////////////////////////////////
|
||||
// Initializer
|
||||
#[no_mangle]
|
||||
#[instrument]
|
||||
pub extern "C" fn initialize_veilid_flutter(dart_post_c_object_ptr: ffi::DartPostCObjectFnType) {
|
||||
unsafe {
|
||||
store_dart_post_cobject(dart_post_c_object_ptr);
|
||||
@ -91,6 +92,7 @@ pub extern "C" fn initialize_veilid_flutter(dart_post_c_object_ptr: ffi::DartPos
|
||||
/// C-compatible FFI Functions
|
||||
|
||||
#[no_mangle]
|
||||
#[instrument]
|
||||
pub extern "C" fn startup_veilid_core(port: i64, config: FfiStr) {
|
||||
let config = config.into_opt_string();
|
||||
let stream = DartIsolateStream::new(port);
|
||||
@ -141,6 +143,7 @@ pub extern "C" fn get_veilid_state(port: i64) {
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
#[instrument(level = "debug")]
|
||||
pub extern "C" fn change_api_log_level(port: i64, log_level: FfiStr) {
|
||||
let log_level = log_level.into_opt_string();
|
||||
DartIsolateWrapper::new(port).spawn_result_json(async move {
|
||||
@ -153,6 +156,7 @@ pub extern "C" fn change_api_log_level(port: i64, log_level: FfiStr) {
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
#[instrument]
|
||||
pub extern "C" fn shutdown_veilid_core(port: i64) {
|
||||
DartIsolateWrapper::new(port).spawn_result_json(async move {
|
||||
let veilid_api = take_veilid_api().await?;
|
||||
@ -184,6 +188,7 @@ pub struct VeilidVersion {
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
#[instrument]
|
||||
pub extern "C" fn veilid_version() -> VeilidVersion {
|
||||
let (major, minor, patch) = veilid_core::veilid_version();
|
||||
VeilidVersion {
|
||||
|
@ -1,6 +1,7 @@
|
||||
pub use allo_isolate::ffi::DartCObject;
|
||||
pub use allo_isolate::IntoDart;
|
||||
use allo_isolate::Isolate;
|
||||
use core::fmt::Debug;
|
||||
use core::future::Future;
|
||||
use parking_lot::Mutex;
|
||||
use serde::*;
|
||||
@ -31,8 +32,8 @@ impl DartIsolateWrapper {
|
||||
pub fn spawn_result<F, T, E>(self, future: F)
|
||||
where
|
||||
F: Future<Output = Result<T, E>> + Send + 'static,
|
||||
T: IntoDart,
|
||||
E: Serialize,
|
||||
T: IntoDart + Debug,
|
||||
E: Serialize + Debug,
|
||||
{
|
||||
async_std::task::spawn(async move {
|
||||
self.result(future.await);
|
||||
@ -42,21 +43,24 @@ impl DartIsolateWrapper {
|
||||
pub fn spawn_result_json<F, T, E>(self, future: F)
|
||||
where
|
||||
F: Future<Output = Result<T, E>> + Send + 'static,
|
||||
T: Serialize,
|
||||
E: Serialize,
|
||||
T: Serialize + Debug,
|
||||
E: Serialize + Debug,
|
||||
{
|
||||
async_std::task::spawn(async move {
|
||||
self.result_json(future.await);
|
||||
});
|
||||
}
|
||||
|
||||
pub fn result<T: IntoDart, E: Serialize>(self, result: Result<T, E>) -> bool {
|
||||
pub fn result<T: IntoDart + Debug, E: Serialize + Debug>(self, result: Result<T, E>) -> bool {
|
||||
match result {
|
||||
Ok(v) => self.ok(v),
|
||||
Err(e) => self.err_json(e),
|
||||
}
|
||||
}
|
||||
pub fn result_json<T: Serialize, E: Serialize>(self, result: Result<T, E>) -> bool {
|
||||
pub fn result_json<T: Serialize + Debug, E: Serialize + Debug>(
|
||||
self,
|
||||
result: Result<T, E>,
|
||||
) -> bool {
|
||||
match result {
|
||||
Ok(v) => self.ok_json(v),
|
||||
Err(e) => self.err_json(e),
|
||||
@ -67,19 +71,19 @@ impl DartIsolateWrapper {
|
||||
.post(vec![MESSAGE_OK.into_dart(), value.into_dart()])
|
||||
}
|
||||
|
||||
pub fn ok_json<T: Serialize>(self, value: T) -> bool {
|
||||
pub fn ok_json<T: Serialize + Debug>(self, value: T) -> bool {
|
||||
self.isolate.post(vec![
|
||||
MESSAGE_OK_JSON.into_dart(),
|
||||
veilid_core::serialize_json(value).into_dart(),
|
||||
])
|
||||
}
|
||||
|
||||
// pub fn err<E: IntoDart>(self, error: E) -> bool {
|
||||
// pub fn err<E: IntoDart + Debug>(self, error: E) -> bool {
|
||||
// self.isolate
|
||||
// .post(vec![MESSAGE_ERR.into_dart(), error.into_dart()])
|
||||
// }
|
||||
|
||||
pub fn err_json<E: Serialize>(self, error: E) -> bool {
|
||||
pub fn err_json<E: Serialize + Debug>(self, error: E) -> bool {
|
||||
self.isolate.post(vec![
|
||||
MESSAGE_ERR_JSON.into_dart(),
|
||||
veilid_core::serialize_json(error).into_dart(),
|
||||
@ -122,7 +126,7 @@ impl DartIsolateStream {
|
||||
// }
|
||||
// }
|
||||
|
||||
pub fn item_json<T: Serialize>(&self, value: T) -> bool {
|
||||
pub fn item_json<T: Serialize + Debug>(&self, value: T) -> bool {
|
||||
let inner = self.inner.lock();
|
||||
if let Some(isolate) = &inner.isolate {
|
||||
isolate.post(vec![
|
||||
@ -134,7 +138,7 @@ impl DartIsolateStream {
|
||||
}
|
||||
}
|
||||
|
||||
// pub fn abort<E: IntoDart>(self, error: E) -> bool {
|
||||
// pub fn abort<E: IntoDart + Debug>(self, error: E) -> bool {
|
||||
// let mut inner = self.inner.lock();
|
||||
// if let Some(isolate) = inner.isolate.take() {
|
||||
// isolate.post(vec![MESSAGE_STREAM_ABORT.into_dart(), error.into_dart()])
|
||||
@ -143,7 +147,7 @@ impl DartIsolateStream {
|
||||
// }
|
||||
// }
|
||||
|
||||
pub fn abort_json<E: Serialize>(self, error: E) -> bool {
|
||||
pub fn abort_json<E: Serialize + Debug>(self, error: E) -> bool {
|
||||
let mut inner = self.inner.lock();
|
||||
if let Some(isolate) = inner.isolate.take() {
|
||||
isolate.post(vec![
|
||||
|
@ -73,6 +73,7 @@ struct VeilidServerImpl {
|
||||
}
|
||||
|
||||
impl VeilidServerImpl {
|
||||
#[instrument(level = "trace", skip_all)]
|
||||
pub fn new(veilid_api: veilid_core::VeilidAPI) -> Self {
|
||||
Self {
|
||||
next_id: 0,
|
||||
@ -83,6 +84,7 @@ impl VeilidServerImpl {
|
||||
}
|
||||
|
||||
impl veilid_server::Server for VeilidServerImpl {
|
||||
#[instrument(level = "trace", skip_all)]
|
||||
fn register(
|
||||
&mut self,
|
||||
params: veilid_server::RegisterParams,
|
||||
@ -126,6 +128,7 @@ impl veilid_server::Server for VeilidServerImpl {
|
||||
})
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip_all)]
|
||||
fn debug(
|
||||
&mut self,
|
||||
params: veilid_server::DebugParams,
|
||||
@ -145,6 +148,7 @@ impl veilid_server::Server for VeilidServerImpl {
|
||||
})
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip_all)]
|
||||
fn attach(
|
||||
&mut self,
|
||||
_params: veilid_server::AttachParams,
|
||||
@ -160,6 +164,7 @@ impl veilid_server::Server for VeilidServerImpl {
|
||||
})
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip_all)]
|
||||
fn detach(
|
||||
&mut self,
|
||||
_params: veilid_server::DetachParams,
|
||||
@ -175,6 +180,7 @@ impl veilid_server::Server for VeilidServerImpl {
|
||||
})
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip_all)]
|
||||
fn shutdown(
|
||||
&mut self,
|
||||
_params: veilid_server::ShutdownParams,
|
||||
@ -194,6 +200,7 @@ impl veilid_server::Server for VeilidServerImpl {
|
||||
Promise::ok(())
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip_all)]
|
||||
fn get_state(
|
||||
&mut self,
|
||||
_params: veilid_server::GetStateParams,
|
||||
@ -239,6 +246,7 @@ pub struct ClientApi {
|
||||
}
|
||||
|
||||
impl ClientApi {
|
||||
#[instrument(level = "trace", skip_all)]
|
||||
pub fn new(veilid_api: veilid_core::VeilidAPI) -> Rc<Self> {
|
||||
Rc::new(Self {
|
||||
inner: RefCell::new(ClientApiInner {
|
||||
@ -250,6 +258,7 @@ impl ClientApi {
|
||||
})
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self))]
|
||||
pub async fn stop(self: Rc<Self>) {
|
||||
trace!("ClientApi::stop requested");
|
||||
let jh = {
|
||||
@ -268,6 +277,7 @@ impl ClientApi {
|
||||
trace!("ClientApi::stop: stopped");
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self, client), err)]
|
||||
async fn handle_incoming(
|
||||
self: Rc<Self>,
|
||||
bind_addr: SocketAddr,
|
||||
@ -301,6 +311,7 @@ impl ClientApi {
|
||||
incoming_loop.await
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip_all)]
|
||||
fn send_request_to_all_clients<F, T>(self: Rc<Self>, request: F)
|
||||
where
|
||||
F: Fn(u64, &mut RegistrationHandle) -> Option<::capnp::capability::RemotePromise<T>>,
|
||||
@ -338,6 +349,7 @@ impl ClientApi {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self))]
|
||||
pub fn handle_update(self: Rc<Self>, veilid_update: veilid_core::VeilidUpdate) {
|
||||
// serialize update
|
||||
let veilid_update = serialize_json(veilid_update);
|
||||
@ -360,6 +372,7 @@ impl ClientApi {
|
||||
});
|
||||
}
|
||||
|
||||
#[instrument(level = "trace", skip(self))]
|
||||
pub fn run(self: Rc<Self>, bind_addrs: Vec<SocketAddr>) {
|
||||
// Create client api VeilidServer
|
||||
let veilid_server_impl = VeilidServerImpl::new(self.inner.borrow().veilid_api.clone());
|
||||
|
@ -15,6 +15,7 @@ mod windows;
|
||||
use async_std::task;
|
||||
use cfg_if::*;
|
||||
use server::*;
|
||||
use tracing::*;
|
||||
use veilid_logs::*;
|
||||
|
||||
#[allow(clippy::all)]
|
||||
@ -22,6 +23,7 @@ pub mod veilid_client_capnp {
|
||||
include!(concat!(env!("OUT_DIR"), "/proto/veilid_client_capnp.rs"));
|
||||
}
|
||||
|
||||
#[instrument(err)]
|
||||
fn main() -> Result<(), String> {
|
||||
#[cfg(windows)]
|
||||
let _ = ansi_term::enable_ansi_support();
|
||||
|
@ -8,7 +8,7 @@ use std::time::{Duration, Instant};
|
||||
use tracing::*;
|
||||
use veilid_core::xx::SingleShotEventual;
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Eq)]
|
||||
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
||||
pub enum ServerMode {
|
||||
Normal,
|
||||
ShutdownImmediate,
|
||||
@ -20,6 +20,7 @@ lazy_static! {
|
||||
Mutex::new(Some(SingleShotEventual::new(Some(()))));
|
||||
}
|
||||
|
||||
#[instrument]
|
||||
pub fn shutdown() {
|
||||
let shutdown_switch = SHUTDOWN_SWITCH.lock().take();
|
||||
if let Some(shutdown_switch) = shutdown_switch {
|
||||
@ -28,13 +29,10 @@ pub fn shutdown() {
|
||||
}
|
||||
|
||||
pub async fn run_veilid_server(settings: Settings, server_mode: ServerMode) -> Result<(), String> {
|
||||
run_veilid_server_internal(settings, server_mode)
|
||||
.await
|
||||
.map_err(|e| {
|
||||
error!("{}", e);
|
||||
e
|
||||
})
|
||||
run_veilid_server_internal(settings, server_mode).await
|
||||
}
|
||||
|
||||
#[instrument(err)]
|
||||
pub async fn run_veilid_server_internal(
|
||||
settings: Settings,
|
||||
server_mode: ServerMode,
|
||||
|
@ -7,7 +7,9 @@ use clap::ArgMatches;
|
||||
use signal_hook::consts::signal::*;
|
||||
use signal_hook_async_std::Signals;
|
||||
use std::io::Read;
|
||||
use tracing::*;
|
||||
|
||||
#[instrument(skip(signals))]
|
||||
async fn handle_signals(mut signals: Signals) {
|
||||
while let Some(signal) = signals.next().await {
|
||||
match signal {
|
||||
@ -23,6 +25,7 @@ async fn handle_signals(mut signals: Signals) {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(err)]
|
||||
pub fn run_daemon(settings: Settings, _matches: ArgMatches) -> Result<(), String> {
|
||||
let daemon = {
|
||||
let mut daemon = daemonize::Daemonize::new();
|
||||
|
Loading…
Reference in New Issue
Block a user