2022-01-16 16:19:01 +00:00
|
|
|
import 'dart:async';
|
2022-01-29 18:23:10 +00:00
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
import 'package:change_case/change_case.dart';
|
2022-02-07 02:18:42 +00:00
|
|
|
|
|
|
|
import 'veilid_stub.dart'
|
2022-02-09 14:47:36 +00:00
|
|
|
if (dart.library.io) 'veilid_ffi.dart'
|
|
|
|
if (dart.library.js) 'veilid_js.dart';
|
2022-02-07 02:18:42 +00:00
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////
|
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
//////////////////////////////////////
|
|
|
|
/// JSON Encode Helper
|
|
|
|
Object? veilidApiToEncodable(Object? value) {
|
|
|
|
if (value == null) {
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
switch (value.runtimeType) {
|
|
|
|
case AttachmentState:
|
|
|
|
return (value as AttachmentState).json;
|
|
|
|
case VeilidLogLevel:
|
|
|
|
return (value as VeilidLogLevel).json;
|
2022-02-10 02:40:01 +00:00
|
|
|
case VeilidConfigLogLevel:
|
|
|
|
return (value as VeilidConfigLogLevel).json;
|
2022-02-09 14:47:36 +00:00
|
|
|
}
|
|
|
|
throw UnsupportedError('Cannot convert to JSON: $value');
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////
|
|
|
|
/// AttachmentState
|
|
|
|
|
2022-02-07 02:18:42 +00:00
|
|
|
enum AttachmentState {
|
2022-02-09 14:47:36 +00:00
|
|
|
detached,
|
|
|
|
attaching,
|
|
|
|
attachedWeak,
|
|
|
|
attachedGood,
|
|
|
|
attachedStrong,
|
|
|
|
fullyAttached,
|
|
|
|
overAttached,
|
|
|
|
detaching,
|
2022-02-07 02:18:42 +00:00
|
|
|
}
|
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
extension AttachmentStateExt on AttachmentState {
|
|
|
|
String get json {
|
|
|
|
return name.toPascalCase();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
AttachmentState attachmentStateFromJson(String j) {
|
|
|
|
return AttachmentState.values.byName(j.toCamelCase());
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////
|
|
|
|
/// VeilidLogLevel
|
|
|
|
|
2022-02-07 02:18:42 +00:00
|
|
|
enum VeilidLogLevel {
|
2022-02-09 14:47:36 +00:00
|
|
|
error,
|
|
|
|
warn,
|
|
|
|
info,
|
|
|
|
debug,
|
|
|
|
trace,
|
2022-02-07 02:18:42 +00:00
|
|
|
}
|
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
extension VeilidLogLevelExt on VeilidLogLevel {
|
|
|
|
String get json {
|
|
|
|
return name.toPascalCase();
|
|
|
|
}
|
|
|
|
}
|
2022-02-07 02:18:42 +00:00
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
VeilidLogLevel veilidLogLevelFromJson(String j) {
|
|
|
|
return VeilidLogLevel.values.byName(j.toCamelCase());
|
|
|
|
}
|
|
|
|
|
2022-02-10 02:40:01 +00:00
|
|
|
//////////////////////////////////////
|
|
|
|
/// VeilidConfigLogLevel
|
|
|
|
|
|
|
|
enum VeilidConfigLogLevel {
|
|
|
|
off,
|
|
|
|
error,
|
|
|
|
warn,
|
|
|
|
info,
|
|
|
|
debug,
|
|
|
|
trace,
|
|
|
|
}
|
|
|
|
|
|
|
|
extension VeilidConfigLogLevelExt on VeilidConfigLogLevel {
|
|
|
|
String get json {
|
|
|
|
return name.toPascalCase();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigLogLevel veilidConfigLogLevelFromJson(String j) {
|
|
|
|
return VeilidConfigLogLevel.values.byName(j.toCamelCase());
|
|
|
|
}
|
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
//////////////////////////////////////
|
|
|
|
/// VeilidConfig
|
|
|
|
|
2022-02-10 02:40:01 +00:00
|
|
|
class VeilidConfigHTTPS {
|
|
|
|
bool enabled;
|
|
|
|
String listenAddress;
|
|
|
|
String path;
|
|
|
|
String? url;
|
|
|
|
|
|
|
|
VeilidConfigHTTPS({
|
|
|
|
required this.enabled,
|
|
|
|
required this.listenAddress,
|
|
|
|
required this.path,
|
|
|
|
this.url,
|
|
|
|
});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'enabled': enabled,
|
|
|
|
'listen_address': listenAddress,
|
|
|
|
'path': path,
|
|
|
|
'url': url
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigHTTPS.fromJson(Map<String, dynamic> json)
|
|
|
|
: enabled = json['enabled'],
|
|
|
|
listenAddress = json['listen_address'],
|
|
|
|
path = json['path'],
|
|
|
|
url = json['url'];
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
|
|
|
class VeilidConfigHTTP {
|
|
|
|
bool enabled;
|
|
|
|
String listenAddress;
|
|
|
|
String path;
|
|
|
|
String? url;
|
|
|
|
|
|
|
|
VeilidConfigHTTP({
|
|
|
|
required this.enabled,
|
|
|
|
required this.listenAddress,
|
|
|
|
required this.path,
|
|
|
|
this.url,
|
|
|
|
});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'enabled': enabled,
|
|
|
|
'listen_address': listenAddress,
|
|
|
|
'path': path,
|
|
|
|
'url': url
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigHTTP.fromJson(Map<String, dynamic> json)
|
|
|
|
: enabled = json['enabled'],
|
|
|
|
listenAddress = json['listen_address'],
|
|
|
|
path = json['path'],
|
|
|
|
url = json['url'];
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
|
|
|
class VeilidConfigApplication {
|
|
|
|
VeilidConfigHTTPS https;
|
|
|
|
VeilidConfigHTTP http;
|
|
|
|
|
|
|
|
VeilidConfigApplication({
|
|
|
|
required this.https,
|
|
|
|
required this.http,
|
|
|
|
});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'https': https.json,
|
|
|
|
'http': http.json,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigApplication.fromJson(Map<String, dynamic> json)
|
|
|
|
: https = VeilidConfigHTTPS.fromJson(json['https']),
|
|
|
|
http = VeilidConfigHTTP.fromJson(json['http']);
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
|
|
|
class VeilidConfigUDP {
|
|
|
|
bool enabled;
|
|
|
|
int socketPoolSize;
|
|
|
|
String listenAddress;
|
|
|
|
String? publicAddress;
|
|
|
|
|
|
|
|
VeilidConfigUDP(
|
|
|
|
{required this.enabled,
|
|
|
|
required this.socketPoolSize,
|
|
|
|
required this.listenAddress,
|
|
|
|
this.publicAddress});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'enabled': enabled,
|
|
|
|
'socket_pool_size': socketPoolSize,
|
|
|
|
'listen_address': listenAddress,
|
|
|
|
'public_address': publicAddress,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigUDP.fromJson(Map<String, dynamic> json)
|
|
|
|
: enabled = json['enabled'],
|
|
|
|
socketPoolSize = json['socket_pool_size'],
|
|
|
|
listenAddress = json['listen_address'],
|
|
|
|
publicAddress = json['publicAddress'];
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
|
|
|
class VeilidConfigTCP {
|
|
|
|
bool connect;
|
|
|
|
bool listen;
|
|
|
|
int maxConnections;
|
|
|
|
String listenAddress;
|
|
|
|
String? publicAddress;
|
|
|
|
|
|
|
|
VeilidConfigTCP(
|
|
|
|
{required this.connect,
|
|
|
|
required this.listen,
|
|
|
|
required this.maxConnections,
|
|
|
|
required this.listenAddress,
|
|
|
|
this.publicAddress});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'connect': connect,
|
|
|
|
'listen': listen,
|
|
|
|
'max_connections': maxConnections,
|
|
|
|
'listen_address': listenAddress,
|
|
|
|
'public_address': publicAddress,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigTCP.fromJson(Map<String, dynamic> json)
|
|
|
|
: connect = json['connect'],
|
|
|
|
listen = json['listen'],
|
|
|
|
maxConnections = json['max_connections'],
|
|
|
|
listenAddress = json['listen_address'],
|
|
|
|
publicAddress = json['publicAddress'];
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
|
|
|
class VeilidConfigWS {
|
|
|
|
bool connect;
|
|
|
|
bool listen;
|
|
|
|
int maxConnections;
|
|
|
|
String listenAddress;
|
|
|
|
String path;
|
|
|
|
String? url;
|
|
|
|
|
|
|
|
VeilidConfigWS(
|
|
|
|
{required this.connect,
|
|
|
|
required this.listen,
|
|
|
|
required this.maxConnections,
|
|
|
|
required this.listenAddress,
|
|
|
|
required this.path,
|
|
|
|
this.url});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'connect': connect,
|
|
|
|
'listen': listen,
|
|
|
|
'max_connections': maxConnections,
|
|
|
|
'listen_address': listenAddress,
|
|
|
|
'path': path,
|
|
|
|
'url': url,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigWS.fromJson(Map<String, dynamic> json)
|
|
|
|
: connect = json['connect'],
|
|
|
|
listen = json['listen'],
|
|
|
|
maxConnections = json['max_connections'],
|
|
|
|
listenAddress = json['listen_address'],
|
|
|
|
path = json['path'],
|
|
|
|
url = json['url'];
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
|
|
|
class VeilidConfigWSS {
|
|
|
|
bool connect;
|
|
|
|
bool listen;
|
|
|
|
int maxConnections;
|
|
|
|
String listenAddress;
|
|
|
|
String path;
|
|
|
|
String? url;
|
|
|
|
|
|
|
|
VeilidConfigWSS(
|
|
|
|
{required this.connect,
|
|
|
|
required this.listen,
|
|
|
|
required this.maxConnections,
|
|
|
|
required this.listenAddress,
|
|
|
|
required this.path,
|
|
|
|
this.url});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'connect': connect,
|
|
|
|
'listen': listen,
|
|
|
|
'max_connections': maxConnections,
|
|
|
|
'listen_address': listenAddress,
|
|
|
|
'path': path,
|
|
|
|
'url': url,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigWSS.fromJson(Map<String, dynamic> json)
|
|
|
|
: connect = json['connect'],
|
|
|
|
listen = json['listen'],
|
|
|
|
maxConnections = json['max_connections'],
|
|
|
|
listenAddress = json['listen_address'],
|
|
|
|
path = json['path'],
|
|
|
|
url = json['url'];
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
|
|
|
class VeilidConfigProtocol {
|
|
|
|
VeilidConfigUDP udp;
|
|
|
|
VeilidConfigTCP tcp;
|
|
|
|
VeilidConfigWS ws;
|
|
|
|
VeilidConfigWSS wss;
|
|
|
|
|
|
|
|
VeilidConfigProtocol({
|
|
|
|
required this.udp,
|
|
|
|
required this.tcp,
|
|
|
|
required this.ws,
|
|
|
|
required this.wss,
|
|
|
|
});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'udp': udp.json,
|
|
|
|
'tcp': tcp.json,
|
|
|
|
'ws': ws.json,
|
|
|
|
'wss': wss.json,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigProtocol.fromJson(Map<String, dynamic> json)
|
|
|
|
: udp = VeilidConfigUDP.fromJson(json['udp']),
|
|
|
|
tcp = VeilidConfigTCP.fromJson(json['tcp']),
|
|
|
|
ws = VeilidConfigWS.fromJson(json['ws']),
|
|
|
|
wss = VeilidConfigWSS.fromJson(json['wss']);
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
|
|
|
class VeilidConfigTLS {
|
|
|
|
String certificatePath;
|
|
|
|
String privateKeyPath;
|
|
|
|
int connectionInitialTimeoutMs;
|
|
|
|
|
|
|
|
VeilidConfigTLS({
|
|
|
|
required this.certificatePath,
|
|
|
|
required this.privateKeyPath,
|
|
|
|
required this.connectionInitialTimeoutMs,
|
|
|
|
});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'certificate_path': certificatePath,
|
|
|
|
'private_key_path': privateKeyPath,
|
|
|
|
'connection_initial_timeout_ms': connectionInitialTimeoutMs,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigTLS.fromJson(Map<String, dynamic> json)
|
|
|
|
: certificatePath = json['certificate_path'],
|
|
|
|
privateKeyPath = json['private_key_path'],
|
|
|
|
connectionInitialTimeoutMs = json['connection_initial_timeout_ms'];
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
|
|
|
class VeilidConfigDHT {
|
|
|
|
int? resolveNodeTimeoutMs;
|
|
|
|
int resolveNodeCount;
|
|
|
|
int resolveNodeFanout;
|
|
|
|
int maxFindNodeCount;
|
|
|
|
int? getValueTimeoutMs;
|
|
|
|
int getValueCount;
|
|
|
|
int getValueFanout;
|
|
|
|
int? setValueTimeoutMs;
|
|
|
|
int setValueCount;
|
|
|
|
int setValueFanout;
|
|
|
|
int minPeerCount;
|
|
|
|
int minPeerRefreshTimeMs;
|
|
|
|
int validateDialInfoReceiptTimeMs;
|
|
|
|
|
|
|
|
VeilidConfigDHT(
|
|
|
|
{this.resolveNodeTimeoutMs,
|
|
|
|
required this.resolveNodeCount,
|
|
|
|
required this.resolveNodeFanout,
|
|
|
|
required this.maxFindNodeCount,
|
|
|
|
this.getValueTimeoutMs,
|
|
|
|
required this.getValueCount,
|
|
|
|
required this.getValueFanout,
|
|
|
|
this.setValueTimeoutMs,
|
|
|
|
required this.setValueCount,
|
|
|
|
required this.setValueFanout,
|
|
|
|
required this.minPeerCount,
|
|
|
|
required this.minPeerRefreshTimeMs,
|
|
|
|
required this.validateDialInfoReceiptTimeMs});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'resolve_node_timeout_ms': resolveNodeTimeoutMs,
|
|
|
|
'resolve_node_count': resolveNodeCount,
|
|
|
|
'resolve_node_fanout': resolveNodeFanout,
|
|
|
|
'max_find_node_count': maxFindNodeCount,
|
|
|
|
'get_value_timeout_ms': getValueTimeoutMs,
|
|
|
|
'get_value_count': getValueCount,
|
|
|
|
'get_value_fanout': getValueFanout,
|
|
|
|
'set_value_timeout_ms': setValueTimeoutMs,
|
|
|
|
'set_value_count': setValueCount,
|
|
|
|
'set_value_fanout': setValueFanout,
|
|
|
|
'min_peer_count': minPeerCount,
|
|
|
|
'min_peer_refresh_time_ms': minPeerRefreshTimeMs,
|
|
|
|
'validate_dial_info_receipt_time_ms': validateDialInfoReceiptTimeMs
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigDHT.fromJson(Map<String, dynamic> json)
|
|
|
|
: resolveNodeTimeoutMs = json['resolve_node_timeout_ms'],
|
|
|
|
resolveNodeCount = json['resolve_node_count'],
|
|
|
|
resolveNodeFanout = json['resolve_node_fanout'],
|
|
|
|
maxFindNodeCount = json['max_find_node_count'],
|
|
|
|
getValueTimeoutMs = json['get_value_timeout_ms'],
|
|
|
|
getValueCount = json['get_value_count'],
|
|
|
|
getValueFanout = json['get_value_fanout'],
|
|
|
|
setValueTimeoutMs = json['set_value_timeout_ms'],
|
|
|
|
setValueCount = json['set_value_count'],
|
|
|
|
setValueFanout = json['set_value_fanout'],
|
|
|
|
minPeerCount = json['min_peer_count'],
|
|
|
|
minPeerRefreshTimeMs = json['min_peer_refresh_time_ms'],
|
|
|
|
validateDialInfoReceiptTimeMs =
|
|
|
|
json['validate_dial_info_receipt_time_ms'];
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
|
|
|
class VeilidConfigRPC {
|
|
|
|
int concurrency;
|
|
|
|
int queueSize;
|
|
|
|
int? maxTimestampBehindMs;
|
|
|
|
int? maxTimestampAheadMs;
|
|
|
|
int timeoutMs;
|
|
|
|
int maxRouteHopCount;
|
|
|
|
|
|
|
|
VeilidConfigRPC(
|
|
|
|
{required this.concurrency,
|
|
|
|
required this.queueSize,
|
|
|
|
this.maxTimestampBehindMs,
|
|
|
|
this.maxTimestampAheadMs,
|
|
|
|
required this.timeoutMs,
|
|
|
|
required this.maxRouteHopCount});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'concurrency': concurrency,
|
|
|
|
'queue_size': queueSize,
|
|
|
|
'max_timestamp_behind_ms': maxTimestampBehindMs,
|
|
|
|
'max_timestamp_ahead_ms': maxTimestampAheadMs,
|
|
|
|
'timeout_ms': timeoutMs,
|
|
|
|
'max_route_hop_count': maxRouteHopCount,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigRPC.fromJson(Map<String, dynamic> json)
|
|
|
|
: concurrency = json['concurrency'],
|
|
|
|
queueSize = json['queue_size'],
|
|
|
|
maxTimestampBehindMs = json['max_timestamp_behind_ms'],
|
|
|
|
maxTimestampAheadMs = json['max_timestamp_ahead_ms'],
|
|
|
|
timeoutMs = json['timeout_ms'],
|
|
|
|
maxRouteHopCount = json['max_route_hop_count'];
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
2022-03-24 14:14:50 +00:00
|
|
|
class VeilidConfigRoutingTable {
|
|
|
|
int limitOverAttached;
|
|
|
|
int limitFullyAttached;
|
|
|
|
int limitAttachedStrong;
|
|
|
|
int limitAttachedGood;
|
|
|
|
int limitAttachedWeak;
|
|
|
|
|
|
|
|
VeilidConfigRoutingTable({
|
|
|
|
required this.limitOverAttached,
|
|
|
|
required this.limitFullyAttached,
|
|
|
|
required this.limitAttachedStrong,
|
|
|
|
required this.limitAttachedGood,
|
|
|
|
required this.limitAttachedWeak,
|
|
|
|
});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'limit_over_attached': limitOverAttached,
|
|
|
|
'limit_fully_attached': limitFullyAttached,
|
|
|
|
'limit_attached_strong': limitAttachedStrong,
|
|
|
|
'limit_attached_good': limitAttachedGood,
|
|
|
|
'limit_attached_weak': limitAttachedWeak,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigRoutingTable.fromJson(Map<String, dynamic> json)
|
|
|
|
: limitOverAttached = json['limit_over_attached'],
|
|
|
|
limitFullyAttached = json['limit_fully_attached'],
|
|
|
|
limitAttachedStrong = json['limit_attached_strong'],
|
|
|
|
limitAttachedGood = json['limit_attached_good'],
|
|
|
|
limitAttachedWeak = json['limit_attached_weak'];
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
2022-02-10 02:40:01 +00:00
|
|
|
class VeilidConfigNetwork {
|
|
|
|
int connectionInitialTimeoutMs;
|
2022-03-19 22:19:40 +00:00
|
|
|
int connectionInactivityTimeoutMs;
|
2022-05-05 00:40:10 +00:00
|
|
|
int maxConnectionsPerIp4;
|
|
|
|
int maxConnectionsPerIp6Prefix;
|
|
|
|
int maxConnectionsPerIp6PrefixSize;
|
|
|
|
int maxConnectionFrequencyPerMin;
|
2022-04-03 16:58:06 +00:00
|
|
|
int clientWhitelistTimeoutMs;
|
2022-05-16 15:52:48 +00:00
|
|
|
int reverseConnectionReceiptTimeMs;
|
|
|
|
int holePunchReceiptTimeMs;
|
2022-02-10 02:40:01 +00:00
|
|
|
String nodeId;
|
|
|
|
String nodeIdSecret;
|
|
|
|
List<String> bootstrap;
|
2022-05-16 15:52:48 +00:00
|
|
|
List<String> bootstrapNodes;
|
2022-03-24 14:14:50 +00:00
|
|
|
VeilidConfigRoutingTable routingTable;
|
2022-02-10 02:40:01 +00:00
|
|
|
VeilidConfigRPC rpc;
|
|
|
|
VeilidConfigDHT dht;
|
|
|
|
bool upnp;
|
|
|
|
bool natpmp;
|
|
|
|
bool enableLocalPeerScope;
|
|
|
|
int restrictedNatRetries;
|
|
|
|
VeilidConfigTLS tls;
|
|
|
|
VeilidConfigApplication application;
|
|
|
|
VeilidConfigProtocol protocol;
|
|
|
|
|
|
|
|
VeilidConfigNetwork({
|
|
|
|
required this.connectionInitialTimeoutMs,
|
2022-03-19 22:19:40 +00:00
|
|
|
required this.connectionInactivityTimeoutMs,
|
2022-05-05 00:40:10 +00:00
|
|
|
required this.maxConnectionsPerIp4,
|
|
|
|
required this.maxConnectionsPerIp6Prefix,
|
|
|
|
required this.maxConnectionsPerIp6PrefixSize,
|
|
|
|
required this.maxConnectionFrequencyPerMin,
|
2022-04-03 16:58:06 +00:00
|
|
|
required this.clientWhitelistTimeoutMs,
|
2022-05-16 15:52:48 +00:00
|
|
|
required this.reverseConnectionReceiptTimeMs,
|
|
|
|
required this.holePunchReceiptTimeMs,
|
2022-02-10 02:40:01 +00:00
|
|
|
required this.nodeId,
|
|
|
|
required this.nodeIdSecret,
|
|
|
|
required this.bootstrap,
|
2022-05-16 15:52:48 +00:00
|
|
|
required this.bootstrapNodes,
|
2022-03-24 14:14:50 +00:00
|
|
|
required this.routingTable,
|
2022-02-10 02:40:01 +00:00
|
|
|
required this.rpc,
|
|
|
|
required this.dht,
|
|
|
|
required this.upnp,
|
|
|
|
required this.natpmp,
|
|
|
|
required this.enableLocalPeerScope,
|
|
|
|
required this.restrictedNatRetries,
|
|
|
|
required this.tls,
|
|
|
|
required this.application,
|
|
|
|
required this.protocol,
|
|
|
|
});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'connection_initial_timeout_ms': connectionInitialTimeoutMs,
|
2022-03-19 22:19:40 +00:00
|
|
|
'connection_inactivity_timeout_ms': connectionInactivityTimeoutMs,
|
2022-05-05 00:40:10 +00:00
|
|
|
'max_connections_per_ip4': maxConnectionsPerIp4,
|
|
|
|
'max_connections_per_ip6_prefix': maxConnectionsPerIp6Prefix,
|
|
|
|
'max_connections_per_ip6_prefix_size': maxConnectionsPerIp6PrefixSize,
|
|
|
|
'max_connection_frequency_per_min': maxConnectionFrequencyPerMin,
|
2022-04-03 16:58:06 +00:00
|
|
|
'client_whitelist_timeout_ms': clientWhitelistTimeoutMs,
|
2022-05-16 15:52:48 +00:00
|
|
|
'reverse_connection_receipt_time_ms': reverseConnectionReceiptTimeMs,
|
|
|
|
'hole_punch_receipt_time_ms': holePunchReceiptTimeMs,
|
2022-02-10 02:40:01 +00:00
|
|
|
'node_id': nodeId,
|
|
|
|
'node_id_secret': nodeIdSecret,
|
|
|
|
'bootstrap': bootstrap,
|
2022-05-16 15:52:48 +00:00
|
|
|
'bootstrap_nodes': bootstrapNodes,
|
2022-03-24 14:14:50 +00:00
|
|
|
'routing_table': routingTable.json,
|
2022-02-10 02:40:01 +00:00
|
|
|
'rpc': rpc.json,
|
|
|
|
'dht': dht.json,
|
|
|
|
'upnp': upnp,
|
|
|
|
'natpmp': natpmp,
|
|
|
|
'enable_local_peer_scope': enableLocalPeerScope,
|
|
|
|
'restricted_nat_retries': restrictedNatRetries,
|
|
|
|
'tls': tls.json,
|
|
|
|
'application': application.json,
|
|
|
|
'protocol': protocol.json,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigNetwork.fromJson(Map<String, dynamic> json)
|
2022-05-05 00:40:10 +00:00
|
|
|
: connectionInitialTimeoutMs = json['connection_initial_timeout_ms'],
|
2022-03-19 22:19:40 +00:00
|
|
|
connectionInactivityTimeoutMs =
|
|
|
|
json['connection_inactivity_timeout_ms'],
|
2022-05-05 00:40:10 +00:00
|
|
|
maxConnectionsPerIp4 = json['max_connections_per_ip4'],
|
|
|
|
maxConnectionsPerIp6Prefix = json['max_connections_per_ip6_prefix'],
|
|
|
|
maxConnectionsPerIp6PrefixSize =
|
|
|
|
json['max_connections_per_ip6_prefix_size'],
|
|
|
|
maxConnectionFrequencyPerMin = json['max_connection_frequency_per_min'],
|
2022-04-03 16:58:06 +00:00
|
|
|
clientWhitelistTimeoutMs = json['client_whitelist_timeout_ms'],
|
2022-05-16 15:52:48 +00:00
|
|
|
reverseConnectionReceiptTimeMs =
|
|
|
|
json['reverse_connection_receipt_time_ms'],
|
|
|
|
holePunchReceiptTimeMs = json['hole_punch_receipt_time_ms'],
|
2022-02-10 02:40:01 +00:00
|
|
|
nodeId = json['node_id'],
|
|
|
|
nodeIdSecret = json['node_id_secret'],
|
|
|
|
bootstrap = json['bootstrap'],
|
2022-05-16 15:52:48 +00:00
|
|
|
bootstrapNodes = json['bootstrap_nodes'],
|
2022-03-24 14:14:50 +00:00
|
|
|
routingTable = VeilidConfigRoutingTable.fromJson(json['routing_table']),
|
2022-02-10 02:40:01 +00:00
|
|
|
rpc = VeilidConfigRPC.fromJson(json['rpc']),
|
|
|
|
dht = VeilidConfigDHT.fromJson(json['dht']),
|
|
|
|
upnp = json['upnp'],
|
|
|
|
natpmp = json['natpmp'],
|
|
|
|
enableLocalPeerScope = json['enable_local_peer_scope'],
|
|
|
|
restrictedNatRetries = json['restricted_nat_retries'],
|
|
|
|
tls = VeilidConfigTLS.fromJson(json['tls']),
|
|
|
|
application = VeilidConfigApplication.fromJson(json['application']),
|
2022-05-16 15:52:48 +00:00
|
|
|
protocol = VeilidConfigProtocol.fromJson(json['protocol']);
|
2022-02-10 02:40:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
|
|
|
class VeilidConfigTableStore {
|
|
|
|
String directory;
|
|
|
|
bool delete;
|
|
|
|
|
|
|
|
VeilidConfigTableStore({
|
|
|
|
required this.directory,
|
|
|
|
required this.delete,
|
|
|
|
});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {'directory': directory, 'delete': delete};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigTableStore.fromJson(Map<String, dynamic> json)
|
|
|
|
: directory = json['directory'],
|
|
|
|
delete = json['delete'];
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
|
|
|
class VeilidConfigBlockStore {
|
|
|
|
String directory;
|
|
|
|
bool delete;
|
|
|
|
|
|
|
|
VeilidConfigBlockStore({
|
|
|
|
required this.directory,
|
|
|
|
required this.delete,
|
|
|
|
});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {'directory': directory, 'delete': delete};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigBlockStore.fromJson(Map<String, dynamic> json)
|
|
|
|
: directory = json['directory'],
|
|
|
|
delete = json['delete'];
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
|
|
|
class VeilidConfigProtectedStore {
|
|
|
|
bool allowInsecureFallback;
|
|
|
|
bool alwaysUseInsecureStorage;
|
|
|
|
String insecureFallbackDirectory;
|
|
|
|
bool delete;
|
|
|
|
|
|
|
|
VeilidConfigProtectedStore({
|
|
|
|
required this.allowInsecureFallback,
|
|
|
|
required this.alwaysUseInsecureStorage,
|
|
|
|
required this.insecureFallbackDirectory,
|
|
|
|
required this.delete,
|
|
|
|
});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'allow_insecure_fallback': allowInsecureFallback,
|
|
|
|
'always_use_insecure_storage': alwaysUseInsecureStorage,
|
|
|
|
'insecure_fallback_directory': insecureFallbackDirectory,
|
|
|
|
'delete': delete,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigProtectedStore.fromJson(Map<String, dynamic> json)
|
|
|
|
: allowInsecureFallback = json['allow_insecure_fallback'],
|
|
|
|
alwaysUseInsecureStorage = json['always_use_insecure_storage'],
|
|
|
|
insecureFallbackDirectory = json['insecure_fallback_directory'],
|
|
|
|
delete = json['delete'];
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
|
|
|
class VeilidConfigCapabilities {
|
|
|
|
bool protocolUDP;
|
|
|
|
bool protocolConnectTCP;
|
|
|
|
bool protocolAcceptTCP;
|
|
|
|
bool protocolConnectWS;
|
|
|
|
bool protocolAcceptWS;
|
|
|
|
bool protocolConnectWSS;
|
|
|
|
bool protocolAcceptWSS;
|
|
|
|
|
|
|
|
VeilidConfigCapabilities({
|
|
|
|
required this.protocolUDP,
|
|
|
|
required this.protocolConnectTCP,
|
|
|
|
required this.protocolAcceptTCP,
|
|
|
|
required this.protocolConnectWS,
|
|
|
|
required this.protocolAcceptWS,
|
|
|
|
required this.protocolConnectWSS,
|
|
|
|
required this.protocolAcceptWSS,
|
|
|
|
});
|
|
|
|
|
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'protocol_udp': protocolUDP,
|
|
|
|
'protocol_connect_tcp': protocolConnectTCP,
|
|
|
|
'protocol_accept_tcp': protocolAcceptTCP,
|
|
|
|
'protocol_connect_ws': protocolConnectWS,
|
|
|
|
'protocol_accept_ws': protocolAcceptWS,
|
|
|
|
'protocol_connect_wss': protocolConnectWSS,
|
|
|
|
'protocol_accept_wss': protocolAcceptWSS,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
VeilidConfigCapabilities.fromJson(Map<String, dynamic> json)
|
|
|
|
: protocolUDP = json['protocol_udp'],
|
|
|
|
protocolConnectTCP = json['protocol_connect_tcp'],
|
|
|
|
protocolAcceptTCP = json['protocol_accept_tcp'],
|
|
|
|
protocolConnectWS = json['protocol_connect_ws'],
|
|
|
|
protocolAcceptWS = json['protocol_accept_ws'],
|
|
|
|
protocolConnectWSS = json['protocol_connect_wss'],
|
|
|
|
protocolAcceptWSS = json['protocol_accept_wss'];
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////
|
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
class VeilidConfig {
|
|
|
|
String programName;
|
2022-02-10 02:40:01 +00:00
|
|
|
String namespace;
|
2022-06-08 01:31:05 +00:00
|
|
|
VeilidConfigLogLevel apiLogLevel;
|
2022-02-10 02:40:01 +00:00
|
|
|
VeilidConfigCapabilities capabilities;
|
|
|
|
VeilidConfigProtectedStore protectedStore;
|
|
|
|
VeilidConfigTableStore tableStore;
|
|
|
|
VeilidConfigBlockStore blockStore;
|
|
|
|
VeilidConfigNetwork network;
|
2022-02-07 02:18:42 +00:00
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
VeilidConfig({
|
|
|
|
required this.programName,
|
2022-02-10 02:40:01 +00:00
|
|
|
required this.namespace,
|
2022-06-08 01:31:05 +00:00
|
|
|
required this.apiLogLevel,
|
2022-02-10 02:40:01 +00:00
|
|
|
required this.capabilities,
|
|
|
|
required this.protectedStore,
|
|
|
|
required this.tableStore,
|
|
|
|
required this.blockStore,
|
|
|
|
required this.network,
|
2022-02-07 02:18:42 +00:00
|
|
|
});
|
2022-02-09 14:47:36 +00:00
|
|
|
|
2022-02-10 02:40:01 +00:00
|
|
|
Map<String, dynamic> get json {
|
|
|
|
return {
|
|
|
|
'program_name': programName,
|
|
|
|
'namespace': namespace,
|
2022-06-08 01:31:05 +00:00
|
|
|
'api_log_level': apiLogLevel.json,
|
2022-02-10 02:40:01 +00:00
|
|
|
'capabilities': capabilities.json,
|
|
|
|
'protected_store': protectedStore.json,
|
|
|
|
'table_store': tableStore.json,
|
|
|
|
'block_store': blockStore.json,
|
|
|
|
'network': network.json
|
|
|
|
};
|
2022-02-09 14:47:36 +00:00
|
|
|
}
|
2022-02-10 02:40:01 +00:00
|
|
|
|
|
|
|
VeilidConfig.fromJson(Map<String, dynamic> json)
|
|
|
|
: programName = json['program_name'],
|
|
|
|
namespace = json['namespace'],
|
2022-06-08 01:31:05 +00:00
|
|
|
apiLogLevel = json['api_log_level'],
|
2022-02-10 02:40:01 +00:00
|
|
|
capabilities = VeilidConfigCapabilities.fromJson(json['capabilities']),
|
|
|
|
protectedStore =
|
|
|
|
VeilidConfigProtectedStore.fromJson(json['protected_store']),
|
|
|
|
tableStore = VeilidConfigTableStore.fromJson(json['table_store']),
|
|
|
|
blockStore = VeilidConfigBlockStore.fromJson(json['block_store']),
|
|
|
|
network = VeilidConfigNetwork.fromJson(json['network']);
|
2022-02-07 02:18:42 +00:00
|
|
|
}
|
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
//////////////////////////////////////
|
|
|
|
/// VeilidUpdate
|
2022-02-07 02:18:42 +00:00
|
|
|
|
|
|
|
abstract class VeilidUpdate {
|
2022-02-10 02:40:01 +00:00
|
|
|
factory VeilidUpdate.fromJson(Map<String, dynamic> json) {
|
|
|
|
switch (json["kind"]) {
|
2022-02-09 14:47:36 +00:00
|
|
|
case "Log":
|
|
|
|
{
|
|
|
|
return VeilidUpdateLog(
|
2022-06-08 01:31:05 +00:00
|
|
|
veilidLogLevelFromJson(json["api_log_level"]), json["message"]);
|
2022-02-09 14:47:36 +00:00
|
|
|
}
|
|
|
|
case "Attachment":
|
|
|
|
{
|
2022-02-10 02:40:01 +00:00
|
|
|
return VeilidUpdateAttachment(attachmentStateFromJson(json["state"]));
|
2022-02-09 14:47:36 +00:00
|
|
|
}
|
2022-05-16 15:52:48 +00:00
|
|
|
case "Network":
|
|
|
|
{
|
|
|
|
return VeilidUpdateNetwork(
|
|
|
|
json["started"], json["bps_up"], json["bps_down"]);
|
|
|
|
}
|
2022-02-09 14:47:36 +00:00
|
|
|
default:
|
|
|
|
{
|
|
|
|
throw VeilidAPIExceptionInternal(
|
2022-02-10 02:40:01 +00:00
|
|
|
"Invalid VeilidAPIException type: ${json['kind']}");
|
2022-02-09 14:47:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-02-07 02:18:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
class VeilidUpdateLog implements VeilidUpdate {
|
|
|
|
final VeilidLogLevel logLevel;
|
|
|
|
final String message;
|
2022-02-09 14:47:36 +00:00
|
|
|
//
|
2022-02-07 02:18:42 +00:00
|
|
|
VeilidUpdateLog(this.logLevel, this.message);
|
|
|
|
}
|
|
|
|
|
|
|
|
class VeilidUpdateAttachment implements VeilidUpdate {
|
|
|
|
final AttachmentState state;
|
2022-02-09 14:47:36 +00:00
|
|
|
//
|
2022-02-07 02:18:42 +00:00
|
|
|
VeilidUpdateAttachment(this.state);
|
|
|
|
}
|
|
|
|
|
2022-05-16 15:52:48 +00:00
|
|
|
class VeilidUpdateNetwork implements VeilidUpdate {
|
|
|
|
final bool started;
|
|
|
|
final int bpsDown;
|
|
|
|
final int bpsUp;
|
|
|
|
//
|
|
|
|
VeilidUpdateNetwork(this.started, this.bpsDown, this.bpsUp);
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////
|
|
|
|
/// VeilidStateAttachment
|
|
|
|
|
|
|
|
class VeilidStateAttachment {
|
|
|
|
final AttachmentState state;
|
|
|
|
|
|
|
|
VeilidStateAttachment(this.state);
|
|
|
|
|
|
|
|
VeilidStateAttachment.fromJson(Map<String, dynamic> json)
|
|
|
|
: state = attachmentStateFromJson(json['state']);
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////
|
|
|
|
/// VeilidStateNetwork
|
|
|
|
|
|
|
|
class VeilidStateNetwork {
|
|
|
|
final bool started;
|
|
|
|
|
|
|
|
VeilidStateNetwork(this.started);
|
|
|
|
|
|
|
|
VeilidStateNetwork.fromJson(Map<String, dynamic> json)
|
|
|
|
: started = json['started'];
|
|
|
|
}
|
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
//////////////////////////////////////
|
|
|
|
/// VeilidState
|
2022-02-07 02:18:42 +00:00
|
|
|
|
|
|
|
class VeilidState {
|
2022-05-16 15:52:48 +00:00
|
|
|
final VeilidStateAttachment attachment;
|
|
|
|
final VeilidStateNetwork network;
|
2022-02-07 02:18:42 +00:00
|
|
|
|
2022-05-16 15:52:48 +00:00
|
|
|
VeilidState(this.attachment, this.network);
|
2022-02-10 02:40:01 +00:00
|
|
|
|
|
|
|
VeilidState.fromJson(Map<String, dynamic> json)
|
2022-05-16 15:52:48 +00:00
|
|
|
: attachment = VeilidStateAttachment.fromJson(json['attachment']),
|
|
|
|
network = VeilidStateNetwork.fromJson(json['network']);
|
2022-02-07 02:18:42 +00:00
|
|
|
}
|
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
//////////////////////////////////////
|
|
|
|
/// VeilidAPIException
|
2022-02-07 02:18:42 +00:00
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
abstract class VeilidAPIException implements Exception {
|
2022-02-10 02:40:01 +00:00
|
|
|
factory VeilidAPIException.fromJson(Map<String, dynamic> json) {
|
|
|
|
switch (json["kind"]) {
|
2022-02-09 14:47:36 +00:00
|
|
|
case "NotInitialized":
|
|
|
|
{
|
|
|
|
return VeilidAPIExceptionNotInitialized();
|
|
|
|
}
|
|
|
|
case "AlreadyInitialized":
|
|
|
|
{
|
|
|
|
return VeilidAPIExceptionAlreadyInitialized();
|
|
|
|
}
|
|
|
|
case "Timeout":
|
|
|
|
{
|
|
|
|
return VeilidAPIExceptionTimeout();
|
|
|
|
}
|
|
|
|
case "Shutdown":
|
|
|
|
{
|
|
|
|
return VeilidAPIExceptionShutdown();
|
|
|
|
}
|
|
|
|
case "NodeNotFound":
|
|
|
|
{
|
2022-02-10 02:40:01 +00:00
|
|
|
return VeilidAPIExceptionNodeNotFound(json["node_id"]);
|
2022-02-09 14:47:36 +00:00
|
|
|
}
|
|
|
|
case "NoDialInfo":
|
|
|
|
{
|
2022-02-10 02:40:01 +00:00
|
|
|
return VeilidAPIExceptionNoDialInfo(json["node_id"]);
|
2022-02-09 14:47:36 +00:00
|
|
|
}
|
|
|
|
case "Internal":
|
|
|
|
{
|
2022-02-10 02:40:01 +00:00
|
|
|
return VeilidAPIExceptionInternal(json["message"]);
|
2022-02-09 14:47:36 +00:00
|
|
|
}
|
|
|
|
case "Unimplemented":
|
|
|
|
{
|
2022-02-10 02:40:01 +00:00
|
|
|
return VeilidAPIExceptionUnimplemented(json["unimplemented"]);
|
2022-02-09 14:47:36 +00:00
|
|
|
}
|
|
|
|
case "ParseError":
|
|
|
|
{
|
2022-02-10 02:40:01 +00:00
|
|
|
return VeilidAPIExceptionParseError(json["message"], json["value"]);
|
2022-02-09 14:47:36 +00:00
|
|
|
}
|
|
|
|
case "InvalidArgument":
|
|
|
|
{
|
|
|
|
return VeilidAPIExceptionInvalidArgument(
|
2022-02-10 02:40:01 +00:00
|
|
|
json["context"], json["argument"], json["value"]);
|
2022-02-09 14:47:36 +00:00
|
|
|
}
|
|
|
|
case "MissingArgument":
|
|
|
|
{
|
|
|
|
return VeilidAPIExceptionMissingArgument(
|
2022-02-10 02:40:01 +00:00
|
|
|
json["context"], json["argument"]);
|
2022-02-09 14:47:36 +00:00
|
|
|
}
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
throw VeilidAPIExceptionInternal(
|
2022-02-10 02:40:01 +00:00
|
|
|
"Invalid VeilidAPIException type: ${json['kind']}");
|
2022-02-09 14:47:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-02-07 02:18:42 +00:00
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
class VeilidAPIExceptionNotInitialized implements VeilidAPIException {
|
|
|
|
@override
|
|
|
|
String toString() {
|
|
|
|
return "VeilidAPIException: NotInitialized";
|
|
|
|
}
|
|
|
|
}
|
2022-02-07 02:18:42 +00:00
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
class VeilidAPIExceptionAlreadyInitialized implements VeilidAPIException {
|
|
|
|
@override
|
|
|
|
String toString() {
|
|
|
|
return "VeilidAPIException: AlreadyInitialized";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class VeilidAPIExceptionTimeout implements VeilidAPIException {
|
|
|
|
@override
|
|
|
|
String toString() {
|
|
|
|
return "VeilidAPIException: Timeout";
|
|
|
|
}
|
|
|
|
}
|
2022-02-07 02:18:42 +00:00
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
class VeilidAPIExceptionShutdown implements VeilidAPIException {
|
|
|
|
@override
|
|
|
|
String toString() {
|
|
|
|
return "VeilidAPIException: Shutdown";
|
2022-01-16 16:19:01 +00:00
|
|
|
}
|
2022-02-09 14:47:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
class VeilidAPIExceptionNodeNotFound implements VeilidAPIException {
|
|
|
|
final String nodeId;
|
|
|
|
|
|
|
|
@override
|
|
|
|
String toString() {
|
|
|
|
return "VeilidAPIException: NodeNotFound (nodeId: $nodeId)";
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
VeilidAPIExceptionNodeNotFound(this.nodeId);
|
|
|
|
}
|
|
|
|
|
|
|
|
class VeilidAPIExceptionNoDialInfo implements VeilidAPIException {
|
|
|
|
final String nodeId;
|
|
|
|
|
|
|
|
@override
|
|
|
|
String toString() {
|
|
|
|
return "VeilidAPIException: NoDialInfo (nodeId: $nodeId)";
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
VeilidAPIExceptionNoDialInfo(this.nodeId);
|
|
|
|
}
|
|
|
|
|
|
|
|
class VeilidAPIExceptionInternal implements VeilidAPIException {
|
|
|
|
final String message;
|
|
|
|
|
|
|
|
@override
|
|
|
|
String toString() {
|
|
|
|
return "VeilidAPIException: Internal ($message)";
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
VeilidAPIExceptionInternal(this.message);
|
|
|
|
}
|
|
|
|
|
|
|
|
class VeilidAPIExceptionUnimplemented implements VeilidAPIException {
|
|
|
|
final String message;
|
|
|
|
|
|
|
|
@override
|
|
|
|
String toString() {
|
|
|
|
return "VeilidAPIException: Unimplemented ($message)";
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
VeilidAPIExceptionUnimplemented(this.message);
|
|
|
|
}
|
|
|
|
|
|
|
|
class VeilidAPIExceptionParseError implements VeilidAPIException {
|
|
|
|
final String message;
|
|
|
|
final String value;
|
|
|
|
|
|
|
|
@override
|
|
|
|
String toString() {
|
|
|
|
return "VeilidAPIException: ParseError ($message)\n value: $value";
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
VeilidAPIExceptionParseError(this.message, this.value);
|
|
|
|
}
|
|
|
|
|
|
|
|
class VeilidAPIExceptionInvalidArgument implements VeilidAPIException {
|
|
|
|
final String context;
|
|
|
|
final String argument;
|
|
|
|
final String value;
|
|
|
|
|
|
|
|
@override
|
|
|
|
String toString() {
|
|
|
|
return "VeilidAPIException: InvalidArgument ($context:$argument)\n value: $value";
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
VeilidAPIExceptionInvalidArgument(this.context, this.argument, this.value);
|
|
|
|
}
|
|
|
|
|
|
|
|
class VeilidAPIExceptionMissingArgument implements VeilidAPIException {
|
|
|
|
final String context;
|
|
|
|
final String argument;
|
|
|
|
|
|
|
|
@override
|
|
|
|
String toString() {
|
|
|
|
return "VeilidAPIException: MissingArgument ($context:$argument)";
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
VeilidAPIExceptionMissingArgument(this.context, this.argument);
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////
|
|
|
|
/// VeilidVersion
|
|
|
|
|
|
|
|
class VeilidVersion {
|
|
|
|
final int major;
|
|
|
|
final int minor;
|
|
|
|
final int patch;
|
|
|
|
|
|
|
|
VeilidVersion(this.major, this.minor, this.patch);
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////
|
|
|
|
/// Veilid singleton factory
|
|
|
|
|
|
|
|
abstract class Veilid {
|
|
|
|
static late Veilid instance = getVeilid();
|
2022-01-29 18:23:10 +00:00
|
|
|
|
2022-02-09 14:47:36 +00:00
|
|
|
Stream<VeilidUpdate> startupVeilidCore(VeilidConfig config);
|
|
|
|
Future<VeilidState> getVeilidState();
|
2022-06-08 01:31:05 +00:00
|
|
|
Future<void> changeApiLogLevel(VeilidConfigLogLevel logLevel);
|
2022-02-09 14:47:36 +00:00
|
|
|
Future<void> shutdownVeilidCore();
|
2022-03-04 01:45:39 +00:00
|
|
|
Future<String> debug(String command);
|
2022-03-17 14:31:10 +00:00
|
|
|
String veilidVersionString();
|
|
|
|
VeilidVersion veilidVersion();
|
2022-01-16 16:19:01 +00:00
|
|
|
}
|