IntenseWebs/veilid
3
0
Fork 0
mirror of https://gitlab.com/veilid/veilid.git synced 2025-02-25 18:55:38 -06:00
Code Issues Packages Projects Releases Wiki Activity

move toward api logging

Browse Source
This commit is contained in:
John Smith 2022-01-31 10:11:18 -05:00
parent cc328d30fa
commit 29b5ec5334
11 changed files with 454 additions and 473 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
veilid-core/src/intf/native/utils/android/mod.rs
View File

@ -23,22 +23,7 @@ lazy_static! {
pub static ref ANDROID_GLOBALS: Arc<Mutex<Option<AndroidGlobals>>> = Arc::new(Mutex::new(None)); pub static ref ANDROID_GLOBALS: Arc<Mutex<Option<AndroidGlobals>>> = Arc::new(Mutex::new(None));
} }
pub fn veilid_core_setup_android<'a>( pub fn veilid_core_setup_android_no_log<'a>(env: JNIEnv<'a>, ctx: JObject<'a>) {
env: JNIEnv<'a>,
ctx: JObject<'a>,
log_tag: &'a str,
log_level: Level,
) {
android_logger::init_once(
Config::default()
.with_min_level(log_level)
.with_tag(log_tag)
.with_filter(
FilterBuilder::new()
.filter(Some(log_tag), log_level.to_level_filter())
.build(),
),
);
panic::set_hook(Box::new(|panic_info| { panic::set_hook(Box::new(|panic_info| {
let bt = Backtrace::new(); let bt = Backtrace::new();
if let Some(location) = panic_info.location() { if let Some(location) = panic_info.location() {
@ -68,6 +53,26 @@ pub fn veilid_core_setup_android<'a>(
}); });
} }
pub fn veilid_core_setup_android<'a>(
env: JNIEnv<'a>,
ctx: JObject<'a>,
log_tag: &'a str,
log_level: Level,
) {
android_logger::init_once(
Config::default()
.with_min_level(log_level)
.with_tag(log_tag)
.with_filter(
FilterBuilder::new()
.filter(Some(log_tag), log_level.to_level_filter())
.build(),
),
);
veilid_core_setup_android_no_log(env, ctx);
}
pub fn get_android_globals() -> (JavaVM, GlobalRef) { pub fn get_android_globals() -> (JavaVM, GlobalRef) {
let globals_locked = ANDROID_GLOBALS.lock(); let globals_locked = ANDROID_GLOBALS.lock();
let globals = globals_locked.as_ref().unwrap(); let globals = globals_locked.as_ref().unwrap();

2
veilid-core/src/tests/common/test_veilid_config.rs
View File

@ -175,6 +175,7 @@ pub fn config_callback(key: String) -> ConfigCallbackReturn {
match key.as_str() { match key.as_str() {
"program_name" => Ok(Box::new(String::from("Veilid"))), "program_name" => Ok(Box::new(String::from("Veilid"))),
"namespace" => Ok(Box::new(String::from(""))), "namespace" => Ok(Box::new(String::from(""))),
"log_to_api" => Ok(Box::new(false)),
"capabilities.protocol_udp" => Ok(Box::new(true)), "capabilities.protocol_udp" => Ok(Box::new(true)),
"capabilities.protocol_connect_tcp" => Ok(Box::new(true)), "capabilities.protocol_connect_tcp" => Ok(Box::new(true)),
"capabilities.protocol_accept_tcp" => Ok(Box::new(true)), "capabilities.protocol_accept_tcp" => Ok(Box::new(true)),
@ -275,6 +276,7 @@ pub async fn test_config() {
let inner = vc.get(); let inner = vc.get();
assert_eq!(inner.program_name, String::from("Veilid")); assert_eq!(inner.program_name, String::from("Veilid"));
assert_eq!(inner.namespace, String::from("")); assert_eq!(inner.namespace, String::from(""));
assert_eq!(inner.log_to_api, false);
assert_eq!(inner.capabilities.protocol_udp, true); assert_eq!(inner.capabilities.protocol_udp, true);
assert_eq!(inner.capabilities.protocol_connect_tcp, true); assert_eq!(inner.capabilities.protocol_connect_tcp, true);
assert_eq!(inner.capabilities.protocol_accept_tcp, true); assert_eq!(inner.capabilities.protocol_accept_tcp, true);

29
veilid-core/src/veilid_api/mod.rs
View File

@ -106,12 +106,34 @@ macro_rules! parse_error {
///////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////
#[derive(Debug)] #[derive(Debug, Clone, Copy)]
pub enum VeilidLogLevel {
Error = 1,
Warn,
Info,
Debug,
Trace,
}
impl VeilidLogLevel {
pub fn from_log_level(level: log::Level) -> VeilidLogLevel {
match level {
Level::Error => VeilidLogLevel::Error,
Level::Warn => VeilidLogLevel::Warn,
Level::Info => VeilidLogLevel::Info,
Level::Debug => VeilidLogLevel::Debug,
Level::Trace => VeilidLogLevel::Trace,
}
}
}
#[derive(Debug, Clone)]
pub enum VeilidUpdate { pub enum VeilidUpdate {
Log(VeilidLogLevel, String),
Attachment(AttachmentState), Attachment(AttachmentState),
} }
#[derive(Debug)] #[derive(Debug, Clone)]
pub struct VeilidState { pub struct VeilidState {
pub attachment: AttachmentState, pub attachment: AttachmentState,
} }
@ -1144,6 +1166,9 @@ impl VeilidAPI {
timeout_ms: Option<u32>, timeout_ms: Option<u32>,
) -> Result<(), VeilidAPIError> { ) -> Result<(), VeilidAPIError> {
match update { match update {
VeilidUpdate::Log(_l, _s) => {
// No point in waiting for a log
}
VeilidUpdate::Attachment(cs) => { VeilidUpdate::Attachment(cs) => {
self.attachment_manager()? self.attachment_manager()?
.wait_for_state(cs, timeout_ms) .wait_for_state(cs, timeout_ms)

2
veilid-core/src/veilid_config.rs
View File

@ -176,6 +176,7 @@ pub struct VeilidConfigCapabilities {
pub struct VeilidConfigInner { pub struct VeilidConfigInner {
pub program_name: String, pub program_name: String,
pub namespace: String, pub namespace: String,
pub log_to_api: bool,
pub capabilities: VeilidConfigCapabilities, pub capabilities: VeilidConfigCapabilities,
pub protected_store: VeilidConfigProtectedStore, pub protected_store: VeilidConfigProtectedStore,
pub table_store: VeilidConfigTableStore, pub table_store: VeilidConfigTableStore,
@ -220,6 +221,7 @@ impl VeilidConfig {
let mut inner = self.inner.write(); let mut inner = self.inner.write();
get_config!(inner.program_name); get_config!(inner.program_name);
get_config!(inner.namespace); get_config!(inner.namespace);
get_config!(inner.log_to_api);
get_config!(inner.capabilities.protocol_udp); get_config!(inner.capabilities.protocol_udp);
get_config!(inner.capabilities.protocol_connect_tcp); get_config!(inner.capabilities.protocol_connect_tcp);
get_config!(inner.capabilities.protocol_accept_tcp); get_config!(inner.capabilities.protocol_accept_tcp);

6
veilid-flutter/android/src/main/kotlin/com/veilid/veilid/VeilidPlugin.kt
View File

@ -16,6 +16,12 @@ class VeilidPlugin: FlutterPlugin, MethodCallHandler {
/// when the Flutter Engine is detached from the Activity /// when the Flutter Engine is detached from the Activity
// private lateinit var channel : MethodChannel // private lateinit var channel : MethodChannel
// static {
// System.loadLibrary("veilid_flutter");
// }
// xxx get main activity
// private static native void init_android(Context context);
override fun onAttachedToEngine(@NonNull flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) { override fun onAttachedToEngine(@NonNull flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
// channel = MethodChannel(flutterPluginBinding.binaryMessenger, "veilid") // channel = MethodChannel(flutterPluginBinding.binaryMessenger, "veilid")
// channel.setMethodCallHandler(this) // channel.setMethodCallHandler(this)

779
veilid-flutter/lib/bridge_generated.dart
View File

@ -1,519 +1,434 @@
// AUTO GENERATED FILE, DO NOT EDIT. // AUTO GENERATED FILE, DO NOT EDIT.
// Generated by `flutter_rust_bridge`. // Generated by `flutter_rust_bridge`.
// ignore_for_file: non_constant_identifier_names, unused_element, duplicate_ignore, directives_ordering, curly_braces_in_flow_control_structures, unnecessary_lambdas, slash_for_doc_comments, prefer_const_literals_to_create_immutables, implicit_dynamic_list_literal, duplicate_import, unused_import // ignore_for_file: non_constant_identifier_names, unused_element, duplicate_ignore, directives_ordering, curly_braces_in_flow_control_structures, unnecessary_lambdas, slash_for_doc_comments, prefer_const_literals_to_create_immutables, implicit_dynamic_list_literal, duplicate_import, unused_import
import 'dart:convert'; import 'dart:convert';
import 'dart:typed_data'; import 'dart:typed_data';
import 'package:freezed_annotation/freezed_annotation.dart'; import 'package:freezed_annotation/freezed_annotation.dart';
import 'dart:convert'; import 'dart:convert';
import 'dart:typed_data'; import 'dart:typed_data';
import 'package:flutter_rust_bridge/flutter_rust_bridge.dart'; import 'package:flutter_rust_bridge/flutter_rust_bridge.dart';
import 'dart:ffi' as ffi; import 'dart:ffi' as ffi;
part 'bridge_generated.freezed.dart'; part 'bridge_generated.freezed.dart';
abstract class VeilidFlutter { abstract class VeilidFlutter {
Stream<VeilidUpdate> startupVeilidCore( Stream<VeilidUpdate> startupVeilidCore({ required VeilidConfig config,dynamic hint });
{required VeilidConfig config, dynamic hint});
Future<VeilidState> getVeilidState({dynamic hint}); Future<VeilidState> getVeilidState({ dynamic hint });
Future<void> shutdownVeilidCore({dynamic hint}); Future<void> shutdownVeilidCore({ dynamic hint });
Future<String> veilidVersionString({dynamic hint}); Future<String> veilidVersionString({ dynamic hint });
Future<VeilidVersion> veilidVersion({dynamic hint}); Future<VeilidVersion> veilidVersion({ dynamic hint });
} }
enum AttachmentState { enum AttachmentState {
Detached, Detached,
Attaching, Attaching,
AttachedWeak, AttachedWeak,
AttachedGood, AttachedGood,
AttachedStrong, AttachedStrong,
FullyAttached, FullyAttached,
OverAttached, OverAttached,
Detaching, Detaching,
} }
class VeilidConfig { class VeilidConfig {
final String programName; final String programName;
final String veilidNamespace; final String veilidNamespace;
final bool capabilitiesProtocolUdp; final bool capabilitiesProtocolUdp;
final bool capabilitiesProtocolConnectTcp; final bool capabilitiesProtocolConnectTcp;
final bool capabilitiesProtocolAcceptTcp; final bool capabilitiesProtocolAcceptTcp;
final bool capabilitiesProtocolConnectWs; final bool capabilitiesProtocolConnectWs;
final bool capabilitiesProtocolAcceptWs; final bool capabilitiesProtocolAcceptWs;
final bool capabilitiesProtocolConnectWss; final bool capabilitiesProtocolConnectWss;
final bool capabilitiesProtocolAcceptWss; final bool capabilitiesProtocolAcceptWss;
final bool protectedStoreAllowInsecureFallback; final bool protectedStoreAllowInsecureFallback;
final bool protectedStoreAlwaysUseInsecureStorage; final bool protectedStoreAlwaysUseInsecureStorage;
final String protectedStoreInsecureFallbackDirectory; final String protectedStoreInsecureFallbackDirectory;
final bool protectedStoreDelete; final bool protectedStoreDelete;
final String tableStoreDirectory; final String tableStoreDirectory;
final bool tableStoreDelete; final bool tableStoreDelete;
final String blockStoreDirectory; final String blockStoreDirectory;
final bool blockStoreDelete; final bool blockStoreDelete;
final int networkMaxConnections; final int networkMaxConnections;
final int networkConnectionInitialTimeoutMs; final int networkConnectionInitialTimeoutMs;
final String networkNodeId; final String networkNodeId;
final String networkNodeIdSecret; final String networkNodeIdSecret;
final List<String> networkBootstrap; final List<String> networkBootstrap;
final bool networkUpnp; final bool networkUpnp;
final bool networkNatpmp; final bool networkNatpmp;
final bool networkEnableLocalPeerScope; final bool networkEnableLocalPeerScope;
final int networkRestrictedNatRetries; final int networkRestrictedNatRetries;
final int networkRpcConcurrency; final int networkRpcConcurrency;
final int networkRpcQueueSize; final int networkRpcQueueSize;
final int? networkRpcMaxTimestampBehindMs; final int? networkRpcMaxTimestampBehindMs;
final int? networkRpcMaxTimestampAheadMs; final int? networkRpcMaxTimestampAheadMs;
final int networkRpcTimeoutMs; final int networkRpcTimeoutMs;
final int networkRpcMaxRouteHopCount; final int networkRpcMaxRouteHopCount;
final int? networkDhtResolveNodeTimeoutMs; final int? networkDhtResolveNodeTimeoutMs;
final int networkDhtResolveNodeCount; final int networkDhtResolveNodeCount;
final int networkDhtResolveNodeFanout; final int networkDhtResolveNodeFanout;
final int networkDhtMaxFindNodeCount; final int networkDhtMaxFindNodeCount;
final int? networkDhtGetValueTimeoutMs; final int? networkDhtGetValueTimeoutMs;
final int networkDhtGetValueCount; final int networkDhtGetValueCount;
final int networkDhtGetValueFanout; final int networkDhtGetValueFanout;
final int? networkDhtSetValueTimeoutMs; final int? networkDhtSetValueTimeoutMs;
final int networkDhtSetValueCount; final int networkDhtSetValueCount;
final int networkDhtSetValueFanout; final int networkDhtSetValueFanout;
final int networkDhtMinPeerCount; final int networkDhtMinPeerCount;
final int networkDhtMinPeerRefreshTimeMs; final int networkDhtMinPeerRefreshTimeMs;
final int networkDhtValidateDialInfoReceiptTimeMs; final int networkDhtValidateDialInfoReceiptTimeMs;
final bool networkProtocolUdpEnabled; final bool networkProtocolUdpEnabled;
final int networkProtocolUdpSocketPoolSize; final int networkProtocolUdpSocketPoolSize;
final String networkProtocolUdpListenAddress; final String networkProtocolUdpListenAddress;
final String? networkProtocolUdpPublicAddress; final String? networkProtocolUdpPublicAddress;
final bool networkProtocolTcpConnect; final bool networkProtocolTcpConnect;
final bool networkProtocolTcpListen; final bool networkProtocolTcpListen;
final int networkProtocolTcpMaxConnections; final int networkProtocolTcpMaxConnections;
final String networkProtocolTcpListenAddress; final String networkProtocolTcpListenAddress;
final String? networkProtocolTcpPublicAddress; final String? networkProtocolTcpPublicAddress;
final bool networkProtocolWsConnect; final bool networkProtocolWsConnect;
final bool networkProtocolWsListen; final bool networkProtocolWsListen;
final int networkProtocolWsMaxConnections; final int networkProtocolWsMaxConnections;
final String networkProtocolWsListenAddress; final String networkProtocolWsListenAddress;
final String networkProtocolWsPath; final String networkProtocolWsPath;
final String? networkProtocolWsUrl; final String? networkProtocolWsUrl;
final bool networkProtocolWssConnect; final bool networkProtocolWssConnect;
final int networkProtocolWssMaxConnections; final int networkProtocolWssMaxConnections;
final int networkLeasesMaxServerSignalLeases; final int networkLeasesMaxServerSignalLeases;
final int networkLeasesMaxServerRelayLeases; final int networkLeasesMaxServerRelayLeases;
final int networkLeasesMaxClientSignalLeases; final int networkLeasesMaxClientSignalLeases;
final int networkLeasesMaxClientRelayLeases; final int networkLeasesMaxClientRelayLeases;
VeilidConfig({ VeilidConfig({required this.programName,required this.veilidNamespace,required this.capabilitiesProtocolUdp,required this.capabilitiesProtocolConnectTcp,required this.capabilitiesProtocolAcceptTcp,required this.capabilitiesProtocolConnectWs,required this.capabilitiesProtocolAcceptWs,required this.capabilitiesProtocolConnectWss,required this.capabilitiesProtocolAcceptWss,required this.protectedStoreAllowInsecureFallback,required this.protectedStoreAlwaysUseInsecureStorage,required this.protectedStoreInsecureFallbackDirectory,required this.protectedStoreDelete,required this.tableStoreDirectory,required this.tableStoreDelete,required this.blockStoreDirectory,required this.blockStoreDelete,required this.networkMaxConnections,required this.networkConnectionInitialTimeoutMs,required this.networkNodeId,required this.networkNodeIdSecret,required this.networkBootstrap,required this.networkUpnp,required this.networkNatpmp,required this.networkEnableLocalPeerScope,required this.networkRestrictedNatRetries,required this.networkRpcConcurrency,required this.networkRpcQueueSize,this.networkRpcMaxTimestampBehindMs,this.networkRpcMaxTimestampAheadMs,required this.networkRpcTimeoutMs,required this.networkRpcMaxRouteHopCount,this.networkDhtResolveNodeTimeoutMs,required this.networkDhtResolveNodeCount,required this.networkDhtResolveNodeFanout,required this.networkDhtMaxFindNodeCount,this.networkDhtGetValueTimeoutMs,required this.networkDhtGetValueCount,required this.networkDhtGetValueFanout,this.networkDhtSetValueTimeoutMs,required this.networkDhtSetValueCount,required this.networkDhtSetValueFanout,required this.networkDhtMinPeerCount,required this.networkDhtMinPeerRefreshTimeMs,required this.networkDhtValidateDialInfoReceiptTimeMs,required this.networkProtocolUdpEnabled,required this.networkProtocolUdpSocketPoolSize,required this.networkProtocolUdpListenAddress,this.networkProtocolUdpPublicAddress,required this.networkProtocolTcpConnect,required this.networkProtocolTcpListen,required this.networkProtocolTcpMaxConnections,required this.networkProtocolTcpListenAddress,this.networkProtocolTcpPublicAddress,required this.networkProtocolWsConnect,required this.networkProtocolWsListen,required this.networkProtocolWsMaxConnections,required this.networkProtocolWsListenAddress,required this.networkProtocolWsPath,this.networkProtocolWsUrl,required this.networkProtocolWssConnect,required this.networkProtocolWssMaxConnections,required this.networkLeasesMaxServerSignalLeases,required this.networkLeasesMaxServerRelayLeases,required this.networkLeasesMaxClientSignalLeases,required this.networkLeasesMaxClientRelayLeases,});
required this.programName, }
required this.veilidNamespace,
required this.capabilitiesProtocolUdp, enum VeilidLogLevel {
required this.capabilitiesProtocolConnectTcp, Error,
required this.capabilitiesProtocolAcceptTcp, Warn,
required this.capabilitiesProtocolConnectWs, Info,
required this.capabilitiesProtocolAcceptWs, Debug,
required this.capabilitiesProtocolConnectWss, Trace,
required this.capabilitiesProtocolAcceptWss, }
required this.protectedStoreAllowInsecureFallback,
required this.protectedStoreAlwaysUseInsecureStorage,
required this.protectedStoreInsecureFallbackDirectory,
required this.protectedStoreDelete,
required this.tableStoreDirectory,
required this.tableStoreDelete,
required this.blockStoreDirectory,
required this.blockStoreDelete,
required this.networkMaxConnections,
required this.networkConnectionInitialTimeoutMs,
required this.networkNodeId,
required this.networkNodeIdSecret,
required this.networkBootstrap,
required this.networkUpnp,
required this.networkNatpmp,
required this.networkEnableLocalPeerScope,
required this.networkRestrictedNatRetries,
required this.networkRpcConcurrency,
required this.networkRpcQueueSize,
this.networkRpcMaxTimestampBehindMs,
this.networkRpcMaxTimestampAheadMs,
required this.networkRpcTimeoutMs,
required this.networkRpcMaxRouteHopCount,
this.networkDhtResolveNodeTimeoutMs,
required this.networkDhtResolveNodeCount,
required this.networkDhtResolveNodeFanout,
required this.networkDhtMaxFindNodeCount,
this.networkDhtGetValueTimeoutMs,
required this.networkDhtGetValueCount,
required this.networkDhtGetValueFanout,
this.networkDhtSetValueTimeoutMs,
required this.networkDhtSetValueCount,
required this.networkDhtSetValueFanout,
required this.networkDhtMinPeerCount,
required this.networkDhtMinPeerRefreshTimeMs,
required this.networkDhtValidateDialInfoReceiptTimeMs,
required this.networkProtocolUdpEnabled,
required this.networkProtocolUdpSocketPoolSize,
required this.networkProtocolUdpListenAddress,
this.networkProtocolUdpPublicAddress,
required this.networkProtocolTcpConnect,
required this.networkProtocolTcpListen,
required this.networkProtocolTcpMaxConnections,
required this.networkProtocolTcpListenAddress,
this.networkProtocolTcpPublicAddress,
required this.networkProtocolWsConnect,
required this.networkProtocolWsListen,
required this.networkProtocolWsMaxConnections,
required this.networkProtocolWsListenAddress,
required this.networkProtocolWsPath,
this.networkProtocolWsUrl,
required this.networkProtocolWssConnect,
required this.networkProtocolWssMaxConnections,
required this.networkLeasesMaxServerSignalLeases,
required this.networkLeasesMaxServerRelayLeases,
required this.networkLeasesMaxClientSignalLeases,
required this.networkLeasesMaxClientRelayLeases,
});
}
class VeilidState { class VeilidState {
final AttachmentState attachment; final AttachmentState attachment;
VeilidState({ VeilidState({required this.attachment,});
required this.attachment, }
});
}
@freezed @freezed
class VeilidUpdate with _$VeilidUpdate { class VeilidUpdate with _$VeilidUpdate {
const factory VeilidUpdate.attachment( const factory VeilidUpdate.log(VeilidLogLevel field0,,String field1,) = Log;
AttachmentState field0, const factory VeilidUpdate.attachment(AttachmentState field0,) = Attachment;
) = Attachment; }
}
class VeilidVersion { class VeilidVersion {
final int major; final int major;
final int minor; final int minor;
final int patch; final int patch;
VeilidVersion({ VeilidVersion({required this.major,required this.minor,required this.patch,});
required this.major, }
required this.minor,
required this.patch,
});
}
class VeilidFlutterImpl extends FlutterRustBridgeBase<VeilidFlutterWire> class VeilidFlutterImpl extends FlutterRustBridgeBase<VeilidFlutterWire> implements VeilidFlutter {
implements VeilidFlutter { factory VeilidFlutterImpl(ffi.DynamicLibrary dylib) => VeilidFlutterImpl.raw(VeilidFlutterWire(dylib));
factory VeilidFlutterImpl(ffi.DynamicLibrary dylib) =>
VeilidFlutterImpl.raw(VeilidFlutterWire(dylib));
VeilidFlutterImpl.raw(VeilidFlutterWire inner) : super(inner); VeilidFlutterImpl.raw(VeilidFlutterWire inner) : super(inner);
Stream<VeilidUpdate> startupVeilidCore( Stream<VeilidUpdate> startupVeilidCore({ required VeilidConfig config,dynamic hint }) => executeStream(FlutterRustBridgeTask(
{required VeilidConfig config, dynamic hint}) => callFfi: (port_) => inner.wire_startup_veilid_core(port_, _api2wire_box_autoadd_veilid_config(config)),
executeStream(FlutterRustBridgeTask( parseSuccessData: _wire2api_veilid_update,
callFfi: (port_) => inner.wire_startup_veilid_core(
port_, _api2wire_box_autoadd_veilid_config(config)),
parseSuccessData: _wire2api_veilid_update,
constMeta: const FlutterRustBridgeTaskConstMeta( constMeta: const FlutterRustBridgeTaskConstMeta(
debugName: "startup_veilid_core", debugName: "startup_veilid_core",
argNames: ["config"], argNames: ["config"],
), ),
argValues: [config], argValues: [config],
hint: hint, hint: hint,
));
));
Future<VeilidState> getVeilidState({dynamic hint}) => Future<VeilidState> getVeilidState({ dynamic hint }) => executeNormal(FlutterRustBridgeTask(
executeNormal(FlutterRustBridgeTask( callFfi: (port_) => inner.wire_get_veilid_state(port_),
callFfi: (port_) => inner.wire_get_veilid_state(port_), parseSuccessData: _wire2api_veilid_state,
parseSuccessData: _wire2api_veilid_state,
constMeta: const FlutterRustBridgeTaskConstMeta( constMeta: const FlutterRustBridgeTaskConstMeta(
debugName: "get_veilid_state", debugName: "get_veilid_state",
argNames: [], argNames: [],
), ),
argValues: [], argValues: [],
hint: hint, hint: hint,
));
));
Future<void> shutdownVeilidCore({dynamic hint}) => Future<void> shutdownVeilidCore({ dynamic hint }) => executeNormal(FlutterRustBridgeTask(
executeNormal(FlutterRustBridgeTask( callFfi: (port_) => inner.wire_shutdown_veilid_core(port_),
callFfi: (port_) => inner.wire_shutdown_veilid_core(port_), parseSuccessData: _wire2api_unit,
parseSuccessData: _wire2api_unit,
constMeta: const FlutterRustBridgeTaskConstMeta( constMeta: const FlutterRustBridgeTaskConstMeta(
debugName: "shutdown_veilid_core", debugName: "shutdown_veilid_core",
argNames: [], argNames: [],
), ),
argValues: [], argValues: [],
hint: hint, hint: hint,
));
));
Future<String> veilidVersionString({dynamic hint}) => Future<String> veilidVersionString({ dynamic hint }) => executeNormal(FlutterRustBridgeTask(
executeNormal(FlutterRustBridgeTask( callFfi: (port_) => inner.wire_veilid_version_string(port_),
callFfi: (port_) => inner.wire_veilid_version_string(port_), parseSuccessData: _wire2api_String,
parseSuccessData: _wire2api_String,
constMeta: const FlutterRustBridgeTaskConstMeta( constMeta: const FlutterRustBridgeTaskConstMeta(
debugName: "veilid_version_string", debugName: "veilid_version_string",
argNames: [], argNames: [],
), ),
argValues: [], argValues: [],
hint: hint, hint: hint,
));
));
Future<VeilidVersion> veilidVersion({dynamic hint}) => Future<VeilidVersion> veilidVersion({ dynamic hint }) => executeNormal(FlutterRustBridgeTask(
executeNormal(FlutterRustBridgeTask( callFfi: (port_) => inner.wire_veilid_version(port_),
callFfi: (port_) => inner.wire_veilid_version(port_), parseSuccessData: _wire2api_veilid_version,
parseSuccessData: _wire2api_veilid_version,
constMeta: const FlutterRustBridgeTaskConstMeta( constMeta: const FlutterRustBridgeTaskConstMeta(
debugName: "veilid_version", debugName: "veilid_version",
argNames: [], argNames: [],
), ),
argValues: [], argValues: [],
hint: hint, hint: hint,
));
));
// Section: api2wire // Section: api2wire
ffi.Pointer<wire_uint_8_list> _api2wire_String(String raw) { ffi.Pointer<wire_uint_8_list> _api2wire_String(String raw) {
return _api2wire_uint_8_list(utf8.encoder.convert(raw)); return _api2wire_uint_8_list(utf8.encoder.convert(raw));
} }
ffi.Pointer<wire_StringList> _api2wire_StringList(List<String> raw) { ffi.Pointer<wire_StringList> _api2wire_StringList(List<String> raw) {
final ans = inner.new_StringList(raw.length); final ans = inner.new_StringList(raw.length);
for (var i = 0; i < raw.length; i++) { for (var i = 0; i < raw.length; i++) {
ans.ref.ptr[i] = _api2wire_String(raw[i]); ans.ref.ptr[i] = _api2wire_String(raw[i]);
} }
return ans; return ans;
} }
int _api2wire_bool(bool raw) { int _api2wire_bool(bool raw) {
return raw ? 1 : 0; return raw ? 1 : 0;
} }
ffi.Pointer<ffi.Uint32> _api2wire_box_autoadd_u32(int raw) { ffi.Pointer<ffi.Uint32> _api2wire_box_autoadd_u32(int raw) {
return inner.new_box_autoadd_u32(raw); return inner.new_box_autoadd_u32(raw);
} }
ffi.Pointer<wire_VeilidConfig> _api2wire_box_autoadd_veilid_config( ffi.Pointer<wire_VeilidConfig> _api2wire_box_autoadd_veilid_config(VeilidConfig raw) {
VeilidConfig raw) { final ptr = inner.new_box_autoadd_veilid_config();
final ptr = inner.new_box_autoadd_veilid_config(); _api_fill_to_wire_veilid_config(raw, ptr.ref);
_api_fill_to_wire_veilid_config(raw, ptr.ref); return ptr;
return ptr; }
}
ffi.Pointer<wire_uint_8_list> _api2wire_opt_String(String? raw) { ffi.Pointer<wire_uint_8_list> _api2wire_opt_String(String? raw) {
return raw == null ? ffi.nullptr : _api2wire_String(raw); return raw == null ? ffi.nullptr : _api2wire_String(raw);
} }
ffi.Pointer<ffi.Uint32> _api2wire_opt_box_autoadd_u32(int? raw) { ffi.Pointer<ffi.Uint32> _api2wire_opt_box_autoadd_u32(int? raw) {
return raw == null ? ffi.nullptr : _api2wire_box_autoadd_u32(raw); return raw == null ? ffi.nullptr : _api2wire_box_autoadd_u32(raw);
} }
int _api2wire_u32(int raw) { int _api2wire_u32(int raw) {
return raw; return raw;
} }
int _api2wire_u8(int raw) { int _api2wire_u8(int raw) {
return raw; return raw;
} }
ffi.Pointer<wire_uint_8_list> _api2wire_uint_8_list(Uint8List raw) { ffi.Pointer<wire_uint_8_list> _api2wire_uint_8_list(Uint8List raw) {
final ans = inner.new_uint_8_list(raw.length); final ans = inner.new_uint_8_list(raw.length);
ans.ref.ptr.asTypedList(raw.length).setAll(0, raw); ans.ref.ptr.asTypedList(raw.length).setAll(0, raw);
return ans; return ans;
} }
// Section: api_fill_to_wire
void _api_fill_to_wire_box_autoadd_veilid_config(
VeilidConfig apiObj, ffi.Pointer<wire_VeilidConfig> wireObj) {
_api_fill_to_wire_veilid_config(apiObj, wireObj.ref);
}
void _api_fill_to_wire_veilid_config( // Section: api_fill_to_wire
VeilidConfig apiObj, wire_VeilidConfig wireObj) {
wireObj.program_name = _api2wire_String(apiObj.programName);
wireObj.veilid_namespace = _api2wire_String(apiObj.veilidNamespace);
wireObj.capabilities__protocol_udp =
_api2wire_bool(apiObj.capabilitiesProtocolUdp);
wireObj.capabilities__protocol_connect_tcp =
_api2wire_bool(apiObj.capabilitiesProtocolConnectTcp);
wireObj.capabilities__protocol_accept_tcp =
_api2wire_bool(apiObj.capabilitiesProtocolAcceptTcp);
wireObj.capabilities__protocol_connect_ws =
_api2wire_bool(apiObj.capabilitiesProtocolConnectWs);
wireObj.capabilities__protocol_accept_ws =
_api2wire_bool(apiObj.capabilitiesProtocolAcceptWs);
wireObj.capabilities__protocol_connect_wss =
_api2wire_bool(apiObj.capabilitiesProtocolConnectWss);
wireObj.capabilities__protocol_accept_wss =
_api2wire_bool(apiObj.capabilitiesProtocolAcceptWss);
wireObj.protected_store__allow_insecure_fallback =
_api2wire_bool(apiObj.protectedStoreAllowInsecureFallback);
wireObj.protected_store__always_use_insecure_storage =
_api2wire_bool(apiObj.protectedStoreAlwaysUseInsecureStorage);
wireObj.protected_store__insecure_fallback_directory =
_api2wire_String(apiObj.protectedStoreInsecureFallbackDirectory);
wireObj.protected_store__delete =
_api2wire_bool(apiObj.protectedStoreDelete);
wireObj.table_store__directory =
_api2wire_String(apiObj.tableStoreDirectory);
wireObj.table_store__delete = _api2wire_bool(apiObj.tableStoreDelete);
wireObj.block_store__directory =
_api2wire_String(apiObj.blockStoreDirectory);
wireObj.block_store__delete = _api2wire_bool(apiObj.blockStoreDelete);
wireObj.network__max_connections =
_api2wire_u32(apiObj.networkMaxConnections);
wireObj.network__connection_initial_timeout_ms =
_api2wire_u32(apiObj.networkConnectionInitialTimeoutMs);
wireObj.network__node_id = _api2wire_String(apiObj.networkNodeId);
wireObj.network__node_id_secret =
_api2wire_String(apiObj.networkNodeIdSecret);
wireObj.network__bootstrap = _api2wire_StringList(apiObj.networkBootstrap);
wireObj.network__upnp = _api2wire_bool(apiObj.networkUpnp);
wireObj.network__natpmp = _api2wire_bool(apiObj.networkNatpmp);
wireObj.network__enable_local_peer_scope =
_api2wire_bool(apiObj.networkEnableLocalPeerScope);
wireObj.network__restricted_nat_retries =
_api2wire_u32(apiObj.networkRestrictedNatRetries);
wireObj.network__rpc__concurrency =
_api2wire_u32(apiObj.networkRpcConcurrency);
wireObj.network__rpc__queue_size =
_api2wire_u32(apiObj.networkRpcQueueSize);
wireObj.network__rpc__max_timestamp_behind_ms =
_api2wire_opt_box_autoadd_u32(apiObj.networkRpcMaxTimestampBehindMs);
wireObj.network__rpc__max_timestamp_ahead_ms =
_api2wire_opt_box_autoadd_u32(apiObj.networkRpcMaxTimestampAheadMs);
wireObj.network__rpc__timeout_ms =
_api2wire_u32(apiObj.networkRpcTimeoutMs);
wireObj.network__rpc__max_route_hop_count =
_api2wire_u8(apiObj.networkRpcMaxRouteHopCount);
wireObj.network__dht__resolve_node_timeout_ms =
_api2wire_opt_box_autoadd_u32(apiObj.networkDhtResolveNodeTimeoutMs);
wireObj.network__dht__resolve_node_count =
_api2wire_u32(apiObj.networkDhtResolveNodeCount);
wireObj.network__dht__resolve_node_fanout =
_api2wire_u32(apiObj.networkDhtResolveNodeFanout);
wireObj.network__dht__max_find_node_count =
_api2wire_u32(apiObj.networkDhtMaxFindNodeCount);
wireObj.network__dht__get_value_timeout_ms =
_api2wire_opt_box_autoadd_u32(apiObj.networkDhtGetValueTimeoutMs);
wireObj.network__dht__get_value_count =
_api2wire_u32(apiObj.networkDhtGetValueCount);
wireObj.network__dht__get_value_fanout =
_api2wire_u32(apiObj.networkDhtGetValueFanout);
wireObj.network__dht__set_value_timeout_ms =
_api2wire_opt_box_autoadd_u32(apiObj.networkDhtSetValueTimeoutMs);
wireObj.network__dht__set_value_count =
_api2wire_u32(apiObj.networkDhtSetValueCount);
wireObj.network__dht__set_value_fanout =
_api2wire_u32(apiObj.networkDhtSetValueFanout);
wireObj.network__dht__min_peer_count =
_api2wire_u32(apiObj.networkDhtMinPeerCount);
wireObj.network__dht__min_peer_refresh_time_ms =
_api2wire_u32(apiObj.networkDhtMinPeerRefreshTimeMs);
wireObj.network__dht__validate_dial_info_receipt_time_ms =
_api2wire_u32(apiObj.networkDhtValidateDialInfoReceiptTimeMs);
wireObj.network__protocol__udp__enabled =
_api2wire_bool(apiObj.networkProtocolUdpEnabled);
wireObj.network__protocol__udp__socket_pool_size =
_api2wire_u32(apiObj.networkProtocolUdpSocketPoolSize);
wireObj.network__protocol__udp__listen_address =
_api2wire_String(apiObj.networkProtocolUdpListenAddress);
wireObj.network__protocol__udp__public_address =
_api2wire_opt_String(apiObj.networkProtocolUdpPublicAddress);
wireObj.network__protocol__tcp__connect =
_api2wire_bool(apiObj.networkProtocolTcpConnect);
wireObj.network__protocol__tcp__listen =
_api2wire_bool(apiObj.networkProtocolTcpListen);
wireObj.network__protocol__tcp__max_connections =
_api2wire_u32(apiObj.networkProtocolTcpMaxConnections);
wireObj.network__protocol__tcp__listen_address =
_api2wire_String(apiObj.networkProtocolTcpListenAddress);
wireObj.network__protocol__tcp__public_address =
_api2wire_opt_String(apiObj.networkProtocolTcpPublicAddress);
wireObj.network__protocol__ws__connect =
_api2wire_bool(apiObj.networkProtocolWsConnect);
wireObj.network__protocol__ws__listen =
_api2wire_bool(apiObj.networkProtocolWsListen);
wireObj.network__protocol__ws__max_connections =
_api2wire_u32(apiObj.networkProtocolWsMaxConnections);
wireObj.network__protocol__ws__listen_address =
_api2wire_String(apiObj.networkProtocolWsListenAddress);
wireObj.network__protocol__ws__path =
_api2wire_String(apiObj.networkProtocolWsPath);
wireObj.network__protocol__ws__url =
_api2wire_opt_String(apiObj.networkProtocolWsUrl);
wireObj.network__protocol__wss__connect =
_api2wire_bool(apiObj.networkProtocolWssConnect);
wireObj.network__protocol__wss__max_connections =
_api2wire_u32(apiObj.networkProtocolWssMaxConnections);
wireObj.network__leases__max_server_signal_leases =
_api2wire_u32(apiObj.networkLeasesMaxServerSignalLeases);
wireObj.network__leases__max_server_relay_leases =
_api2wire_u32(apiObj.networkLeasesMaxServerRelayLeases);
wireObj.network__leases__max_client_signal_leases =
_api2wire_u32(apiObj.networkLeasesMaxClientSignalLeases);
wireObj.network__leases__max_client_relay_leases =
_api2wire_u32(apiObj.networkLeasesMaxClientRelayLeases);
}
}
// Section: wire2api
String _wire2api_String(dynamic raw) {
return raw as String;
}
void _api_fill_to_wire_box_autoadd_veilid_config(VeilidConfig apiObj, ffi.Pointer<wire_VeilidConfig> wireObj) {
_api_fill_to_wire_veilid_config(apiObj, wireObj.ref);
}
void _api_fill_to_wire_veilid_config(VeilidConfig apiObj, wire_VeilidConfig wireObj) {
wireObj.program_name = _api2wire_String(apiObj.programName);
wireObj.veilid_namespace = _api2wire_String(apiObj.veilidNamespace);
wireObj.capabilities__protocol_udp = _api2wire_bool(apiObj.capabilitiesProtocolUdp);
wireObj.capabilities__protocol_connect_tcp = _api2wire_bool(apiObj.capabilitiesProtocolConnectTcp);
wireObj.capabilities__protocol_accept_tcp = _api2wire_bool(apiObj.capabilitiesProtocolAcceptTcp);
wireObj.capabilities__protocol_connect_ws = _api2wire_bool(apiObj.capabilitiesProtocolConnectWs);
wireObj.capabilities__protocol_accept_ws = _api2wire_bool(apiObj.capabilitiesProtocolAcceptWs);
wireObj.capabilities__protocol_connect_wss = _api2wire_bool(apiObj.capabilitiesProtocolConnectWss);
wireObj.capabilities__protocol_accept_wss = _api2wire_bool(apiObj.capabilitiesProtocolAcceptWss);
wireObj.protected_store__allow_insecure_fallback = _api2wire_bool(apiObj.protectedStoreAllowInsecureFallback);
wireObj.protected_store__always_use_insecure_storage = _api2wire_bool(apiObj.protectedStoreAlwaysUseInsecureStorage);
wireObj.protected_store__insecure_fallback_directory = _api2wire_String(apiObj.protectedStoreInsecureFallbackDirectory);
wireObj.protected_store__delete = _api2wire_bool(apiObj.protectedStoreDelete);
wireObj.table_store__directory = _api2wire_String(apiObj.tableStoreDirectory);
wireObj.table_store__delete = _api2wire_bool(apiObj.tableStoreDelete);
wireObj.block_store__directory = _api2wire_String(apiObj.blockStoreDirectory);
wireObj.block_store__delete = _api2wire_bool(apiObj.blockStoreDelete);
wireObj.network__max_connections = _api2wire_u32(apiObj.networkMaxConnections);
wireObj.network__connection_initial_timeout_ms = _api2wire_u32(apiObj.networkConnectionInitialTimeoutMs);
wireObj.network__node_id = _api2wire_String(apiObj.networkNodeId);
wireObj.network__node_id_secret = _api2wire_String(apiObj.networkNodeIdSecret);
wireObj.network__bootstrap = _api2wire_StringList(apiObj.networkBootstrap);
wireObj.network__upnp = _api2wire_bool(apiObj.networkUpnp);
wireObj.network__natpmp = _api2wire_bool(apiObj.networkNatpmp);
wireObj.network__enable_local_peer_scope = _api2wire_bool(apiObj.networkEnableLocalPeerScope);
wireObj.network__restricted_nat_retries = _api2wire_u32(apiObj.networkRestrictedNatRetries);
wireObj.network__rpc__concurrency = _api2wire_u32(apiObj.networkRpcConcurrency);
wireObj.network__rpc__queue_size = _api2wire_u32(apiObj.networkRpcQueueSize);
wireObj.network__rpc__max_timestamp_behind_ms = _api2wire_opt_box_autoadd_u32(apiObj.networkRpcMaxTimestampBehindMs);
wireObj.network__rpc__max_timestamp_ahead_ms = _api2wire_opt_box_autoadd_u32(apiObj.networkRpcMaxTimestampAheadMs);
wireObj.network__rpc__timeout_ms = _api2wire_u32(apiObj.networkRpcTimeoutMs);
wireObj.network__rpc__max_route_hop_count = _api2wire_u8(apiObj.networkRpcMaxRouteHopCount);
wireObj.network__dht__resolve_node_timeout_ms = _api2wire_opt_box_autoadd_u32(apiObj.networkDhtResolveNodeTimeoutMs);
wireObj.network__dht__resolve_node_count = _api2wire_u32(apiObj.networkDhtResolveNodeCount);
wireObj.network__dht__resolve_node_fanout = _api2wire_u32(apiObj.networkDhtResolveNodeFanout);
wireObj.network__dht__max_find_node_count = _api2wire_u32(apiObj.networkDhtMaxFindNodeCount);
wireObj.network__dht__get_value_timeout_ms = _api2wire_opt_box_autoadd_u32(apiObj.networkDhtGetValueTimeoutMs);
wireObj.network__dht__get_value_count = _api2wire_u32(apiObj.networkDhtGetValueCount);
wireObj.network__dht__get_value_fanout = _api2wire_u32(apiObj.networkDhtGetValueFanout);
wireObj.network__dht__set_value_timeout_ms = _api2wire_opt_box_autoadd_u32(apiObj.networkDhtSetValueTimeoutMs);
wireObj.network__dht__set_value_count = _api2wire_u32(apiObj.networkDhtSetValueCount);
wireObj.network__dht__set_value_fanout = _api2wire_u32(apiObj.networkDhtSetValueFanout);
wireObj.network__dht__min_peer_count = _api2wire_u32(apiObj.networkDhtMinPeerCount);
wireObj.network__dht__min_peer_refresh_time_ms = _api2wire_u32(apiObj.networkDhtMinPeerRefreshTimeMs);
wireObj.network__dht__validate_dial_info_receipt_time_ms = _api2wire_u32(apiObj.networkDhtValidateDialInfoReceiptTimeMs);
wireObj.network__protocol__udp__enabled = _api2wire_bool(apiObj.networkProtocolUdpEnabled);
wireObj.network__protocol__udp__socket_pool_size = _api2wire_u32(apiObj.networkProtocolUdpSocketPoolSize);
wireObj.network__protocol__udp__listen_address = _api2wire_String(apiObj.networkProtocolUdpListenAddress);
wireObj.network__protocol__udp__public_address = _api2wire_opt_String(apiObj.networkProtocolUdpPublicAddress);
wireObj.network__protocol__tcp__connect = _api2wire_bool(apiObj.networkProtocolTcpConnect);
wireObj.network__protocol__tcp__listen = _api2wire_bool(apiObj.networkProtocolTcpListen);
wireObj.network__protocol__tcp__max_connections = _api2wire_u32(apiObj.networkProtocolTcpMaxConnections);
wireObj.network__protocol__tcp__listen_address = _api2wire_String(apiObj.networkProtocolTcpListenAddress);
wireObj.network__protocol__tcp__public_address = _api2wire_opt_String(apiObj.networkProtocolTcpPublicAddress);
wireObj.network__protocol__ws__connect = _api2wire_bool(apiObj.networkProtocolWsConnect);
wireObj.network__protocol__ws__listen = _api2wire_bool(apiObj.networkProtocolWsListen);
wireObj.network__protocol__ws__max_connections = _api2wire_u32(apiObj.networkProtocolWsMaxConnections);
wireObj.network__protocol__ws__listen_address = _api2wire_String(apiObj.networkProtocolWsListenAddress);
wireObj.network__protocol__ws__path = _api2wire_String(apiObj.networkProtocolWsPath);
wireObj.network__protocol__ws__url = _api2wire_opt_String(apiObj.networkProtocolWsUrl);
wireObj.network__protocol__wss__connect = _api2wire_bool(apiObj.networkProtocolWssConnect);
wireObj.network__protocol__wss__max_connections = _api2wire_u32(apiObj.networkProtocolWssMaxConnections);
wireObj.network__leases__max_server_signal_leases = _api2wire_u32(apiObj.networkLeasesMaxServerSignalLeases);
wireObj.network__leases__max_server_relay_leases = _api2wire_u32(apiObj.networkLeasesMaxServerRelayLeases);
wireObj.network__leases__max_client_signal_leases = _api2wire_u32(apiObj.networkLeasesMaxClientSignalLeases);
wireObj.network__leases__max_client_relay_leases = _api2wire_u32(apiObj.networkLeasesMaxClientRelayLeases);
}
}
// Section: wire2api
String _wire2api_String(dynamic raw) {
return raw as String;
}
AttachmentState _wire2api_attachment_state(dynamic raw) { AttachmentState _wire2api_attachment_state(dynamic raw) {
return AttachmentState.values[raw]; return AttachmentState.values[raw];
} }
int _wire2api_u32(dynamic raw) { int _wire2api_u32(dynamic raw) {
return raw as int; return raw as int;
} }
int _wire2api_u8(dynamic raw) { int _wire2api_u8(dynamic raw) {
return raw as int; return raw as int;
} }
Uint8List _wire2api_uint_8_list(dynamic raw) { Uint8List _wire2api_uint_8_list(dynamic raw) {
return raw as Uint8List; return raw as Uint8List;
} }
void _wire2api_unit(dynamic raw) { void _wire2api_unit(dynamic raw) {
return; return;
} }
VeilidLogLevel _wire2api_veilid_log_level(dynamic raw) {
return VeilidLogLevel.values[raw];
}
VeilidState _wire2api_veilid_state(dynamic raw) { VeilidState _wire2api_veilid_state(dynamic raw) {
final arr = raw as List<dynamic>; final arr = raw as List<dynamic>;
if (arr.length != 1) if (arr.length != 1) throw Exception('unexpected arr length: expect 1 but see ${arr.length}');
throw Exception('unexpected arr length: expect 1 but see ${arr.length}'); return VeilidState(attachment: _wire2api_attachment_state(arr[0]),);
return VeilidState( }
attachment: _wire2api_attachment_state(arr[0]),
);
}
VeilidUpdate _wire2api_veilid_update(dynamic raw) { VeilidUpdate _wire2api_veilid_update(dynamic raw) {
switch (raw[0]) { switch (raw[0]) {
case 0: case 0: return Log(_wire2api_veilid_log_level(raw[1]),_wire2api_String(raw[2]),);
return Attachment( case 1: return Attachment(_wire2api_attachment_state(raw[1]),);
_wire2api_attachment_state(raw[1]), default: throw Exception("unreachable");
); }
default: }
throw Exception("unreachable");
}
}
VeilidVersion _wire2api_veilid_version(dynamic raw) { VeilidVersion _wire2api_veilid_version(dynamic raw) {
final arr = raw as List<dynamic>; final arr = raw as List<dynamic>;
if (arr.length != 3) if (arr.length != 3) throw Exception('unexpected arr length: expect 3 but see ${arr.length}');
throw Exception('unexpected arr length: expect 3 but see ${arr.length}'); return VeilidVersion(major: _wire2api_u32(arr[0]),
return VeilidVersion( minor: _wire2api_u32(arr[1]),
major: _wire2api_u32(arr[0]), patch: _wire2api_u32(arr[2]),);
minor: _wire2api_u32(arr[1]), }
patch: _wire2api_u32(arr[2]),
);
}
// ignore_for_file: camel_case_types, non_constant_identifier_names, avoid_positional_boolean_parameters, annotate_overrides, constant_identifier_names // ignore_for_file: camel_case_types, non_constant_identifier_names, avoid_positional_boolean_parameters, annotate_overrides, constant_identifier_names
// AUTO GENERATED FILE, DO NOT EDIT. // AUTO GENERATED FILE, DO NOT EDIT.
@ -886,6 +801,8 @@ class wire_VeilidConfig extends ffi.Struct {
external int network__leases__max_client_relay_leases; external int network__leases__max_client_relay_leases;
} }
typedef DartPostCObjectFnType = ffi.Pointer< typedef DartPostCObjectFnType = ffi.Pointer<
ffi.NativeFunction<ffi.Uint8 Function(DartPort, ffi.Pointer<ffi.Void>)>>; ffi.NativeFunction<ffi.Uint8 Function(DartPort, ffi.Pointer<ffi.Void>)>>;
typedef DartPort = ffi.Int64; typedef DartPort = ffi.Int64;

22
veilid-flutter/rust/src/api.rs
View File

@ -427,14 +427,36 @@ impl AttachmentState {
} }
} }
#[derive(Debug, Clone, Copy)]
pub enum VeilidLogLevel {
Error,
Warn,
Info,
Debug,
Trace,
}
impl VeilidLogLevel {
fn from_core(level: veilid_core::VeilidLogLevel) -> Self {
match level {
veilid_core::VeilidLogLevel::Error => VeilidLogLevel::Error,
veilid_core::VeilidLogLevel::Warn => VeilidLogLevel::Warn,
veilid_core::VeilidLogLevel::Info => VeilidLogLevel::Info,
veilid_core::VeilidLogLevel::Debug => VeilidLogLevel::Debug,
veilid_core::VeilidLogLevel::Trace => VeilidLogLevel::Trace,
}
}
}
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub enum VeilidUpdate { pub enum VeilidUpdate {
Log(VeilidLogLevel, String),
Attachment(AttachmentState), Attachment(AttachmentState),
} }
impl VeilidUpdate { impl VeilidUpdate {
fn from_core(veilid_update: veilid_core::VeilidUpdate) -> Self { fn from_core(veilid_update: veilid_core::VeilidUpdate) -> Self {
match veilid_update { match veilid_update {
veilid_core::VeilidUpdate::Log(ll, s) => Self::Log(VeilidLogLevel::from_core(ll), s),
veilid_core::VeilidUpdate::Attachment(attachment) => { veilid_core::VeilidUpdate::Attachment(attachment) => {
Self::Attachment(AttachmentState::from_core(attachment)) Self::Attachment(AttachmentState::from_core(attachment))
} }

18
veilid-flutter/rust/src/bridge_generated.rs
View File

@ -491,6 +491,19 @@ impl support::IntoDart for AttachmentState {
} }
} }
impl support::IntoDart for VeilidLogLevel {
fn into_dart(self) -> support::DartCObject {
match self {
Self::Error => 0,
Self::Warn => 1,
Self::Info => 2,
Self::Debug => 3,
Self::Trace => 4,
}
.into_dart()
}
}
impl support::IntoDart for VeilidState { impl support::IntoDart for VeilidState {
fn into_dart(self) -> support::DartCObject { fn into_dart(self) -> support::DartCObject {
vec![self.attachment.into_dart()].into_dart() vec![self.attachment.into_dart()].into_dart()
@ -501,7 +514,10 @@ impl support::IntoDartExceptPrimitive for VeilidState {}
impl support::IntoDart for VeilidUpdate { impl support::IntoDart for VeilidUpdate {
fn into_dart(self) -> support::DartCObject { fn into_dart(self) -> support::DartCObject {
match self { match self {
Self::Attachment(field0) => vec![0.into_dart(), field0.into_dart()], Self::Log(field0, field1) => {
vec![0.into_dart(), field0.into_dart(), field1.into_dart()]
}
Self::Attachment(field0) => vec![1.into_dart(), field0.into_dart()],
} }
.into_dart() .into_dart()
} }

27
veilid-flutter/rust/src/lib.rs
View File

@ -3,35 +3,16 @@ mod bridge_generated;
use cfg_if::*; use cfg_if::*;
xxx make this work #[cfg(target_os = "android")]
#[cfg(all(target_os = "android", feature = "android_tests"))]
use jni::{objects::JClass, objects::JObject, JNIEnv}; use jni::{objects::JClass, objects::JObject, JNIEnv};
#[cfg(all(target_os = "android", feature = "android_tests"))] #[cfg(target_os = "android")]
#[no_mangle] #[no_mangle]
#[allow(non_snake_case)] #[allow(non_snake_case)]
pub extern "system" fn Java_com_veilid_veilidcore_veilidcore_1android_1tests_MainActivity_run_1tests( pub extern "system" fn Java_com_veilid_veilid_VeilidPlugin_init_1android(
env: JNIEnv, env: JNIEnv,
_class: JClass, _class: JClass,
ctx: JObject, ctx: JObject,
) { ) {
crate::intf::utils::android::veilid_core_setup_android(env, ctx, "veilid_core", Level::Trace); crate::intf::utils::android::veilid_core_setup_android_no_log(env, ctx);
}
#[cfg(target_os = "ios")]
#[no_mangle]
pub extern "C" fn run_veilid_core_tests(app_name: c_str) {
let log_path: std::path::PathBuf = [
std::env::var("HOME").unwrap().as_str(),
"Documents",
"veilid-core.log",
]
.iter()
.collect();
crate::intf::utils::setup::veilid_core_setup(
"veilid-core",
Some(Level::Trace),
Some((Level::Trace, log_path.as_path())),
);
} }

4
veilid-server/src/client_api.rs
View File

@ -36,6 +36,9 @@ fn convert_update(
rpc_update: crate::veilid_client_capnp::veilid_update::Builder, rpc_update: crate::veilid_client_capnp::veilid_update::Builder,
) { ) {
match update { match update {
veilid_core::VeilidUpdate::Log(_ll, _s) => {
panic!("Should not be logging to api in server!");
}
veilid_core::VeilidUpdate::Attachment(state) => { veilid_core::VeilidUpdate::Attachment(state) => {
let mut att = rpc_update.init_attachment(); let mut att = rpc_update.init_attachment();
att.set_state(convert_attachment_state(state)); att.set_state(convert_attachment_state(state));
@ -358,6 +361,7 @@ impl ClientApi {
} }
pub fn handle_update(self: Rc<Self>, veilid_update: veilid_core::VeilidUpdate) { pub fn handle_update(self: Rc<Self>, veilid_update: veilid_core::VeilidUpdate) {
// Pass other updates to clients
self.send_request_to_all_clients(|_id, registration| { self.send_request_to_all_clients(|_id, registration| {
let mut request = registration.client.update_request(); let mut request = registration.client.update_request();
let rpc_veilid_update = request.get().init_veilid_update(); let rpc_veilid_update = request.get().init_veilid_update();

1
veilid-server/src/settings.rs
View File

@ -751,6 +751,7 @@ impl Settings {
} else { } else {
format!("subnode{}", inner.testing.subnode_index) format!("subnode{}", inner.testing.subnode_index)
})), })),
"log_to_api" => Ok(Box::new(false)),
"capabilities.protocol_udp" => Ok(Box::new(true)), "capabilities.protocol_udp" => Ok(Box::new(true)),
"capabilities.protocol_connect_tcp" => Ok(Box::new(true)), "capabilities.protocol_connect_tcp" => Ok(Box::new(true)),
"capabilities.protocol_accept_tcp" => Ok(Box::new(true)), "capabilities.protocol_accept_tcp" => Ok(Box::new(true)),