bak

Author: timzaak

.github/workflows/spa-server-ci.yml

@@ -14,7 +14,6 @@ jobs:
       - uses: actions/checkout@v3
         with:
           submodules: true
-      - run: rustup toolchain install stable
       - uses: Swatinem/rust-cache@v2
       - name: run integration test
         # --show-output

server/src/admin_server.rs

@@ -1,4 +1,4 @@
- use crate::acme::ACMEManager;
+use crate::acme::ACMEManager;
 use crate::admin_server::request::{
     DeleteDomainVersionOption, DomainWithOptVersionOption, DomainWithVersionOption,
     GetDomainOption, GetDomainPositionOption, UpdateUploadingStatusOption, UploadFileOption,
@@ -44,19 +44,20 @@ impl AdminServer {
 
     fn routes(&self) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
         self.auth().and(
-            warp::get().and(
-                self.get_domain_info()
-                    .or(self.get_domain_upload_path())
-                    .or(self.get_files_metadata())
-                    .or(self.get_acme_cert_info())
-            )
-            .or(warp::post().and(
-                self.update_domain_version()
-                    .or(self.reload_server())
-                    .or(self.change_upload_status())
-                    .or(self.upload_file())
-                    .or(self.remove_domain_version())                 
-            )),
+            warp::get()
+                .and(
+                    self.get_domain_info()
+                        .or(self.get_domain_upload_path())
+                        .or(self.get_files_metadata())
+                        .or(self.get_acme_cert_info()),
+                )
+                .or(warp::post().and(
+                    self.update_domain_version()
+                        .or(self.reload_server())
+                        .or(self.change_upload_status())
+                        .or(self.upload_file())
+                        .or(self.remove_domain_version()),
+                )),
         )
     }
 
@@ -130,7 +131,7 @@ impl AdminServer {
 
     fn change_upload_status(
         &self,
-    ) -> impl Filter<Extract = (impl warp::Reply,), Error = Rejection> + Clone  {
+    ) -> impl Filter<Extract = (impl warp::Reply,), Error = Rejection> + Clone {
         warp::path!("files" / "upload_status")
             .and(with(self.domain_storage.clone()))
             .and(with(self.acme_manager.clone()))
@@ -182,7 +183,9 @@ impl AdminServer {
             .map(service::remove_domain_version)
     }
 
-    fn get_acme_cert_info(&self) -> impl Filter<Extract = (impl warp::Reply,), Error = Rejection> + Clone  {
+    fn get_acme_cert_info(
+        &self,
+    ) -> impl Filter<Extract = (impl warp::Reply,), Error = Rejection> + Clone {
         warp::path!("cert" / "acme")
             .and(with(self.acme_manager.clone()))
             .and(warp::query::<GetDomainOption>())
@@ -296,7 +299,10 @@ pub mod service {
         acme_manager: Arc<ACMEManager>,
         param: UpdateUploadingStatusOption,
     ) -> Result<Response, Infallible> {
-        let resp = match storage.update_uploading_status(param.domain, param.version, param.status, &acme_manager).await {
+        let resp = match storage
+            .update_uploading_status(param.domain, param.version, param.status, &acme_manager)
+            .await
+        {
             Ok(_) => Response::default(),
             Err(e) => {
                 let mut resp = Response::new(Body::from(e.to_string()));
@@ -406,6 +412,25 @@ pub mod service {
         };
         Ok(resp)
     }
+    /*
+    pub(super) async fn revoke_version(
+        domain_storage: Arc<DomainStorage>,
+        query: DomainWithVersionOption,
+    ) -> Result<Response, Infallible>{
+        let DomainWithVersionOption {
+            domain, version
+        } = query;
+        let resp = match domain_storage.get_domain_info_by_domain(&domain) {
+            Some(info)=> {
+                info
+            }
+            None => {
+                not_found()
+            }
+        };
+        Ok(resp)
+    }
+     */
 }
 
 pub mod request {

tests/tests/common.rs

@@ -4,8 +4,9 @@ use reqwest::{ClientBuilder, StatusCode, Url};
 use spa_client::api::API;
 use std::path::{Path, PathBuf};
 use std::{env, fs, io};
+//use tokio::sync::oneshot;
 use tokio::task::JoinHandle;
-use tracing::{error, Level};
+use tracing::{debug, error, Level};
 use tracing_subscriber::EnvFilter;
 
 pub const LOCAL_HOST: &str = "local.fornetcode.com";
@@ -49,13 +50,26 @@ pub fn run_server_with_config(config_file_name: &str) -> JoinHandle<()> {
         )
         .with_test_writer()
         .try_init();
-
-    return tokio::spawn(async {
+    //let (tx, rx) = oneshot::channel::<()>();
+    tokio::spawn(async move {
         let result = spa_server::run_server().await;
         if result.is_err() {
-            error!("spa server run error: {:?}", result.unwrap_err())
+            error!("spa server run error: {:?}", result.unwrap_err());
+        } else {
+            debug!("spa server finish");
         }
-    });
+        // tokio::select! {
+        //     _ = rx => {
+        //         debug!("stop server")
+        //     }
+        //     result = spa_server::run_server() => {
+        //         if result.is_err() {
+        //             error!("spa server run error: {:?}", result.unwrap_err());
+        //         }
+        //     }
+        // }
+    })
+    //tx
 }
 pub fn run_server() -> JoinHandle<()> {
     run_server_with_config("server_config.conf")

tests/tests/starter.rs

@@ -2,10 +2,13 @@ use reqwest::header::LOCATION;
 use reqwest::redirect::Policy;
 use reqwest::{ClientBuilder, StatusCode};
 use std::time::Duration;
+use tokio::time::sleep;
+use tracing::log::debug;
 
 mod common;
 use crate::common::*;
 use common::run_server;
+use spa_server::config::get_host_path_from_domain;
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 3)]
 async fn start_server_and_client_upload_file() {
@@ -139,9 +142,38 @@ async fn evoke_cache_when_serving_new_version() {
 }
 
 // This must run after evoke_cache_when_serving_new_index
-#[ignore]
 #[tokio::test(flavor = "multi_thread", worker_threads = 3)]
 async fn cold_start_server_and_serving_files() {
+    clean_web_domain_dir(LOCAL_HOST);
+    let domain = format!("{LOCAL_HOST}/27");
+    let domain = &domain;
+    let request_prefix = format!("http://{LOCAL_HOST}:8080/27");
+    let request_prefix = &request_prefix;
+    let sender = run_server();
+
+    tokio::time::sleep(Duration::from_secs(1)).await;
+
+    upload_file_and_check(domain, request_prefix, 1, vec![]).await;
+    upload_file_and_check(domain, request_prefix, 2, vec![]).await;
+    upload_file_and_check(domain, request_prefix, 3, vec![]).await;
+    upload_file_and_check(domain, request_prefix, 4, vec![]).await;
+    let mut wait_count = 0;
+    sender.abort();
+
+    debug!("begin to loop server close");
+
+    let (api, _) = get_client_api("client_config.conf");
+    loop {
+        assert!(wait_count < 10, "10 seconds server does not stop");
+        sleep(Duration::from_secs(1)).await;
+        let cert_info = api
+            .get_domain_info(Some(get_host_path_from_domain(domain).0.to_string()))
+            .await;
+        if cert_info.is_err() {
+            break;
+        }
+        wait_count += 1;
+    }
     let domain = format!("{LOCAL_HOST}/27");
     let domain = &domain;
     let request_prefix = format!("http://{LOCAL_HOST}:8080/27");
@@ -152,6 +184,7 @@ async fn cold_start_server_and_serving_files() {
     assert_files(domain, request_prefix, 4, vec!["index.html", "4.html"]).await;
     assert_files(domain, request_prefix, 2, vec!["2.html"]).await;
     assert_files_no_exists(request_prefix, vec!["1.html"]).await;
+    //sender.send(()).unwrap();
 }
 
 #[tokio::test]