json api work

veilid-core/src/veilid_api/json_api/crypto_system.rs

@@ -0,0 +1,66 @@
+use super::*;
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct CryptoSystemRequest {
+    cs_id: String,
+    #[serde(flatten)]
+    cs_op: CryptoSystemRequestOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct CryptoSystemResponse {
+    cs_id: String,
+    #[serde(flatten)]
+    cs_op: CryptoSystemResponseOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "cs_op")]
+pub enum CryptoSystemRequestOp {
+    Release,
+    CachedDh,
+    ComputeDh,
+    RandomBytes,
+    DefaultSaltLength,
+    HashPassword,
+    VerifyPassword,
+    DeriveSharedSecret,
+    RandomNonce,
+    RandomSharedSecret,
+    GenerateKeyPair,
+    GenerateHash,
+    ValidateKeyPair,
+    ValidateHash,
+    Distance,
+    Sign,
+    Verify,
+    AeadOverhead,
+    DecryptAead,
+    EncryptAead,
+    CryptNoAuth,
+}
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "cs_op")]
+pub enum CryptoSystemResponseOp {
+    Release,
+    CachedDh,
+    ComputeDh,
+    RandomBytes,
+    DefaultSaltLength,
+    HashPassword,
+    VerifyPassword,
+    DeriveSharedSecret,
+    RandomNonce,
+    RandomSharedSecret,
+    GenerateKeyPair,
+    GenerateHash,
+    ValidateKeyPair,
+    ValidateHash,
+    Distance,
+    Sign,
+    Verify,
+    AeadOverhead,
+    DecryptAead,
+    EncryptAead,
+    CryptNoAuth,
+}

veilid-core/src/veilid_api/json_api/mod.rs

@@ -0,0 +1,203 @@
+use super::*;
+
+mod routing_context;
+pub use routing_context::*;
+
+mod table_db;
+pub use table_db::*;
+
+mod crypto_system;
+pub use crypto_system::*;
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct Request {
+    /// Operation Id (pairs with Response)
+    id: String,
+    /// The request operation variant
+    #[serde(flatten)]
+    op: RequestOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct Response {
+    /// Operation Id (pairs with Request)
+    id: String,
+    /// The response operation variant
+    #[serde(flatten)]
+    op: ResponseOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "op")]
+pub enum RequestOp {
+    GetState,
+    Attach,
+    Detach,
+    NewPrivateRoute,
+    NewCustomPrivateRoute {
+        #[schemars(with = "Vec<String>")]
+        crypto_kinds: Vec<CryptoKind>,
+        #[serde(default)]
+        stability: Stability,
+        #[serde(default)]
+        sequencing: Sequencing,
+    },
+    ImportRemotePrivateRoute {
+        #[serde(
+            serialize_with = "json_as_base64::serialize",
+            deserialize_with = "json_as_base64::deserialize"
+        )]
+        #[schemars(with = "String")]
+        blob: Vec<u8>,
+    },
+    ReleasePrivateRoute {
+        #[schemars(with = "String")]
+        route_id: RouteId,
+    },
+    AppCallReply {
+        #[schemars(with = "String")]
+        call_id: OperationId,
+        #[serde(
+            serialize_with = "json_as_base64::serialize",
+            deserialize_with = "json_as_base64::deserialize"
+        )]
+        #[schemars(with = "String")]
+        message: Vec<u8>,
+    },
+    // Routing Context
+    NewRoutingContext,
+    RoutingContext(RoutingContextRequest),
+    // TableDb
+    OpenTableDb {
+        name: String,
+        column_count: u32,
+    },
+    DeleteTableDb {
+        name: String,
+    },
+    TableDb(TableDbRequest),
+    // Crypto
+    GetCryptoSystem {
+        #[schemars(with = "String")]
+        crypto_kind: CryptoKind,
+    },
+    BestCryptoSystem,
+    CryptoSystem(CryptoSystemRequest),
+    VerifySignatures {
+        #[schemars(with = "Vec<String>")]
+        node_ids: Vec<TypedKey>,
+        #[serde(
+            serialize_with = "json_as_base64::serialize",
+            deserialize_with = "json_as_base64::deserialize"
+        )]
+        #[schemars(with = "String")]
+        data: Vec<u8>,
+        #[schemars(with = "Vec<String>")]
+        signatures: Vec<TypedSignature>,
+    },
+    GenerateSignatures {
+        #[serde(
+            serialize_with = "json_as_base64::serialize",
+            deserialize_with = "json_as_base64::deserialize"
+        )]
+        #[schemars(with = "String")]
+        data: Vec<u8>,
+        #[schemars(with = "Vec<String>")]
+        key_pairs: Vec<TypedKeyPair>,
+    },
+    GenerateKeyPair {
+        #[schemars(with = "String")]
+        crypto_kind: CryptoKind,
+    },
+    // Misc
+    Now,
+    Debug {
+        command: String,
+    },
+    VeilidVersionString,
+    VeilidVersion,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct NewPrivateRouteResult {
+    #[schemars(with = "String")]
+    route_id: RouteId,
+    #[serde(
+        serialize_with = "json_as_base64::serialize",
+        deserialize_with = "json_as_base64::deserialize"
+    )]
+    #[schemars(with = "String")]
+    blob: Vec<u8>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "op")]
+pub enum ResponseOp {
+    GetState {
+        #[serde(flatten)]
+        result: ApiResult<VeilidState>,
+    },
+    Attach {
+        #[serde(flatten)]
+        result: ApiResult<()>,
+    },
+    Detach {
+        #[serde(flatten)]
+        result: ApiResult<()>,
+    },
+    NewPrivateRoute {
+        #[serde(flatten)]
+        result: ApiResult<NewPrivateRouteResult>,
+    },
+    NewCustomPrivateRoute {
+        #[serde(flatten)]
+        result: ApiResult<NewPrivateRouteResult>,
+    },
+    ImportRemotePrivateRoute,
+    ReleasePrivateRoute,
+    AppCallReply,
+    // Routing Context
+    NewRoutingContext,
+    RoutingContext(RoutingContextResponse),
+    // TableDb
+    OpenTableDb,
+    DeleteTableDb,
+    TableDb(TableDbResponse),
+    // Crypto
+    GetCryptoSystem,
+    BestCryptoSystem,
+    CryptoSystem(CryptoSystemResponse),
+    VerifySignatures,
+    GenerateSignatures,
+    GenerateKeyPair,
+    // Misc
+    Now,
+    Debug,
+    VeilidVersionString,
+    VeilidVersion,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(untagged)]
+pub enum ApiResult<T>
+where
+    T: Clone + fmt::Debug + JsonSchema,
+{
+    Ok { value: T },
+    Err { error: VeilidAPIError },
+}
+
+pub fn emit_schemas(out: &mut HashMap<String, String>) {
+    let schema_request = schema_for!(Request);
+    let schema_response = schema_for!(Response);
+
+    out.insert(
+        "Request".to_owned(),
+        serde_json::to_string_pretty(&schema_request).unwrap(),
+    );
+
+    out.insert(
+        "Response".to_owned(),
+        serde_json::to_string_pretty(&schema_response).unwrap(),
+    );
+}

veilid-core/src/veilid_api/json_api/routing_context.rs

@@ -0,0 +1,52 @@
+use super::*;
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct RoutingContextRequest {
+    rc_id: String,
+    #[serde(flatten)]
+    rc_op: RoutingContextRequestOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct RoutingContextResponse {
+    rc_id: String,
+    #[serde(flatten)]
+    rc_op: RoutingContextResponseOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "rc_op")]
+pub enum RoutingContextRequestOp {
+    Release,
+    WithPrivacy,
+    WithCustomPrivacy,
+    WithSequencing,
+    AppCall,
+    AppMessage,
+    CreateDhtRecord,
+    OpenDhtRecord,
+    CloseDhtRecord,
+    DeleteDhtRecord,
+    GetDhtValue,
+    SetDhtValue,
+    WatchDhtValues,
+    CancelDhtWatch,
+}
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "rc_op")]
+pub enum RoutingContextResponseOp {
+    Release,
+    WithPrivacy,
+    WithCustomPrivacy,
+    WithSequencing,
+    AppCall,
+    AppMessage,
+    CreateDhtRecord,
+    OpenDhtRecord,
+    CloseDhtRecord,
+    DeleteDhtRecord,
+    GetDhtValue,
+    SetDhtValue,
+    WatchDhtValues,
+    CancelDhtWatch,
+}

veilid-core/src/veilid_api/json_api/table_db.rs

@@ -0,0 +1,26 @@
+use super::*;
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct TableDbRequest {
+    db_id: String,
+    #[serde(flatten)]
+    db_op: TableDbRequestOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct TableDbResponse {
+    db_id: String,
+    #[serde(flatten)]
+    db_op: TableDbResponseOp,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "db_op")]
+pub enum TableDbRequestOp {
+    Release,
+}
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "db_op")]
+pub enum TableDbResponseOp {
+    Release,
+}