feat: add update_toggles endpoint

Author: SSebo

Cargo.lock

@@ -51,7 +51,7 @@ tracing-subscriber = { version = "0.3", features = [
 ] }
 url = "2.3"
 socketio-rs = { optional = true, version = "0.1.7", default-features = false, features = ["server"] }
-feature-probe-server-sdk = { version = "1.2.6", features = [
+feature-probe-server-sdk = { version = "1.2.9", features = [
   "internal",
   "use_tokio",
 ], default-features = false }

Cargo.toml

@@ -1,6 +1,6 @@
-use super::{cors_headers, ClientParams, SdkAuthorization};
+use super::{cors_headers, ClientParams, SdkAuthorization, ToggleUpdateParams};
 #[cfg(feature = "unstable")]
-use super::{SecretsParams, SegmentUpdateParams, ToggleUpdateParams};
+use super::{SecretsParams, SegmentUpdateParams};
 use crate::FPServerError::{NotFound, NotReady};
 use crate::{repo::SdkRepository, FPServerError};
 use axum::{
@@ -14,7 +14,7 @@ use feature_probe_event::{
     collector::{EventHandler, FPEventError},
     event::PackedData,
 };
-use feature_probe_server_sdk::{FPUser, Repository, Url};
+use feature_probe_server_sdk::{FPUser, Repository, SyncType, Url};
 use parking_lot::Mutex;
 use reqwest::{
     header::{self, AUTHORIZATION, USER_AGENT},
@@ -42,7 +42,6 @@ pub trait HttpHandler {
         TypedHeader(SdkAuthorization(sdk_key)): TypedHeader<SdkAuthorization>,
     ) -> Result<Response, FPServerError>;
 
-    #[cfg(feature = "unstable")]
     async fn update_toggles(
         &self,
         Json(params): Json<ToggleUpdateParams>,
@@ -128,6 +127,25 @@ impl HttpHandler for FpHttpHandler {
         }
     }
 
+    async fn update_toggles(
+        &self,
+        Json(params): Json<ToggleUpdateParams>,
+    ) -> Result<Response, FPServerError> {
+        let sdk_key = params.sdk_key;
+        match self.repo.client_sync_now(&sdk_key, SyncType::Realtime) {
+            Ok(_sdk_key) => Ok((StatusCode::OK, cors_headers(), "{}").into_response()),
+            Err(e) => match e {
+                NotFound(_) => Ok((
+                    StatusCode::BAD_REQUEST,
+                    [(header::CONTENT_TYPE, "application/json")],
+                    "{}",
+                )
+                    .into_response()),
+                _ => Err(e),
+            },
+        }
+    }
+
     #[cfg(feature = "unstable")]
     async fn update_toggles(
         &self,
@@ -272,14 +290,17 @@ impl HttpHandler for LocalFileHttpHandlerForTest {
             .into_response())
     }
 
-    #[cfg(feature = "unstable")]
     async fn update_toggles(
         &self,
         Json(_params): Json<ToggleUpdateParams>,
     ) -> Result<Response, FPServerError> {
-        let status = StatusCode::OK;
-        let body = "";
-        Ok((status, body).into_response())
+        let body = "{}".to_owned();
+        Ok((
+            StatusCode::OK,
+            [(header::CONTENT_TYPE, "application/json")],
+            body,
+        )
+            .into_response())
     }
 
     #[cfg(feature = "unstable")]

src/http/handler.rs

@@ -15,7 +15,8 @@ use crate::FPServerError;
 use feature_probe_event::collector::{post_events, EventHandler};
 use feature_probe_server_sdk::SdkAuthorization;
 #[cfg(feature = "unstable")]
-use feature_probe_server_sdk::{Segment, Toggle};
+use feature_probe_server_sdk::Segment;
+use feature_probe_server_sdk::Toggle;
 pub use handler::{FpHttpHandler, HttpHandler, LocalFileHttpHandlerForTest};
 use serde::Deserialize;
 use serde_json::json;
@@ -35,14 +36,14 @@ where
         .route("/api/server-sdk/toggles", get(server_sdk_toggles::<T>))
         .route("/api/events", post(post_events::<T>).options(client_cors))
         .route("/internal/all_secrets", get(all_secrets::<T>)) // not for public network
+        .route("/internal/update_toggles", post(update_toggles::<T>))
         .layer(Extension(handler))
         .fallback(handler_404.into_service());
 
     #[cfg(feature = "unstable")]
     let app = app
-        .route("/api/server/toggles", post(update_toggles::<T>))
-        .route("/api/server/segments", post(update_segments::<T>))
-        .route("/api/server/check_secrets", post(check_secrets::<T>));
+        .route("/internal/server/segments", post(update_segments::<T>))
+        .route("/intelnal/server/check_secrets", post(check_secrets::<T>));
 
     let addr = SocketAddr::from(([0, 0, 0, 0], port));
     axum::Server::bind(&addr)
@@ -76,7 +77,6 @@ where
     handler.server_sdk_toggles(sdk_key).await
 }
 
-#[cfg(feature = "unstable")]
 async fn update_toggles<T>(
     params: Json<ToggleUpdateParams>,
     Extension(handler): Extension<T>,
@@ -131,11 +131,14 @@ pub struct ClientParams {
     user: String,
 }
 
-#[cfg(feature = "unstable")]
+#[allow(unused)]
 #[derive(Debug, Deserialize)]
 pub struct ToggleUpdateParams {
     sdk_key: String,
+    #[serde(default)]
     toggles: HashMap<String, Toggle>,
+    #[serde(default)]
+    version: Option<String>,
 }
 
 #[cfg(feature = "unstable")]
@@ -190,6 +193,13 @@ mod tests {
     use serde_json::Value;
     use std::{fs, path::PathBuf, sync::Arc, time::Duration};
 
+    #[test]
+    fn deserialize_toggle_udpate_param() {
+        let toggle_update_param = r#"{"sdk_key": "key1"}"#;
+        let p: ToggleUpdateParams = serde_json::from_str(toggle_update_param).unwrap();
+        assert_eq!(p.sdk_key, "key1");
+    }
+
     #[tokio::test]
     async fn test_fp_server_connect_fp_api() {
         let server_sdk_key = "server-sdk-key1".to_owned();

src/http/mod.rs

@@ -2,7 +2,9 @@
 use crate::realtime::RealtimeSocket;
 use crate::FPServerError;
 use crate::{base::ServerConfig, secrets::SecretMapping};
-use feature_probe_server_sdk::{EvalDetail, FPConfig, FPUser, FeatureProbe as FPClient, Url};
+use feature_probe_server_sdk::{
+    EvalDetail, FPConfig, FPUser, FeatureProbe as FPClient, SyncType, Url,
+};
 #[cfg(feature = "unstable")]
 use feature_probe_server_sdk::{Segment, Toggle};
 use parking_lot::RwLock;
@@ -145,6 +147,16 @@ impl SdkRepository {
         self.inner.all_evaluated_string(server_sdk_key, user)
     }
 
+    pub fn client_sync_now(&self, sdk_key: &str, t: SyncType) -> Result<String, FPServerError> {
+        let sdk_clients = self.inner.sdk_clients.write();
+        let client = match sdk_clients.get(sdk_key) {
+            Some(client) => client,
+            None => return Err(FPServerError::NotFound(sdk_key.to_string())),
+        };
+        client.sync_now(t);
+        Ok(sdk_key.to_string())
+    }
+
     #[cfg(test)]
     #[cfg(feature = "unstable")]
     fn sdk_client(&self, sdk_key: &str) -> Option<FPClient> {
@@ -226,7 +238,7 @@ impl Inner {
             mapping.client_sdk_key(server_sdk_key).cloned()
         };
 
-        client.set_update_callback(Box::new(move |_old, _new| {
+        client.set_update_callback(Box::new(move |_old, _new, _type| {
             let server_key = sdk_key.clone();
             let client_key = client_sdk_key.clone();
             let socket = realtime_socket.clone();
@@ -323,6 +335,9 @@ mod tests {
         let clients = { (repository.inner.sdk_clients.read()).clone() };
         assert!(!clients.contains_key(&server_sdk_key));
         assert!(clients.contains_key(&server_sdk_key2));
+
+        let sdk_key = repository.client_sync_now(&server_sdk_key2, SyncType::Polling);
+        assert!(sdk_key.is_ok());
     }
 
     #[tokio::test]