Split files differently

src/main.rs

@@ -123,7 +123,7 @@ async fn async_main() {
     let video_mutex = Arc::new(Mutex::new(VecDeque::new()));
     let upload_semaphore = Arc::new(Semaphore::new(0));
     let upload_mutex = Arc::new(Mutex::new(VecDeque::new()));
-    let query_lock = Arc::new(tokio::sync::Mutex::new(()));
+    let query_mutex = Arc::new(tokio::sync::Mutex::new(1));
     if !nodl {
         let date_regex = Arc::new(Regex::new(r#" *\d{4}-\d{2}-\d{2} \d{2}:\d{2}$"#).unwrap());
         for _ in 0..config::VIDEO_WORKERS {
@@ -172,14 +172,13 @@ async fn async_main() {
                             }
                             let mutex = video_mutex.clone();
                             let semaphore = video_semaphore.clone();
-                            let query_lock = query_lock.clone();
+                            let query_mutex = query_mutex.clone();
                             let tclient = tclient.clone();
                             let chat = chat.clone();
                             tokio::task::spawn(async move {
                                 let mut waited = false;
-                                let mut i = 1;
                                 loop {
-                                    let guard = query_lock.lock().await;
+                                    let mut guard = query_mutex.lock().await;
                                     match utils::get_video(&j).await {
                                         Ok(Some(i)) => {
                                             let first_try_live =
@@ -190,9 +189,13 @@ async fn async_main() {
                                                 first_try_live,
                                             ));
                                             semaphore.add_permits(1);
+                                            *guard = 1;
+                                            break;
+                                        }
+                                        Ok(None) => {
+                                            *guard = 1;
                                             break;
                                         }
-                                        Ok(None) => break,
                                         Err(err) => {
                                             eprintln!("Failed to get video data: {:?}", err);
                                             waited = true;
@@ -202,8 +205,9 @@ async fn async_main() {
                                                     || output.contains("too many request")
                                                     || output.contains("technical difficult")
                                                 {
-                                                    sleep(Duration::from_secs(i * 60 * 60)).await;
-                                                    i += 1;
+                                                    sleep(Duration::from_secs(*guard * 60 * 60))
+                                                        .await;
+                                                    *guard += 1;
                                                     continue;
                                                 } else if err
                                                     .output

src/workers.rs

@@ -611,12 +611,13 @@ pub async fn upload_worker(
         };
         let total_size = file.seek(SeekFrom::End(0)).await.unwrap();
         file.seek(SeekFrom::Start(0)).await.unwrap();
-        let parts = (total_size as f64 / (2000.0 * 1024.0 * 1024.0)).ceil() as usize;
-        for i in 0..parts {
-            let filename = if parts == 1 {
-                video_filename.clone()
-            } else {
+        let mut sent_size = 0;
+        let split = total_size > 2000 * 1024 * 1024;
+        for i in 0.. {
+            let filename = if split {
                 format!("{}.part{:02}", &video_filename, i)
+            } else {
+                video_filename.clone()
             };
             let message = tclient
                 .send_message(
@@ -666,7 +667,7 @@ pub async fn upload_worker(
                     }
                 };
             }
-            let mut size = total_size - file.stream_position().await.unwrap();
+            let mut size = total_size - sent_size;
             if size > 2000 * 1024 * 1024 {
                 size = 2000 * 1024 * 1024;
             }
@@ -717,6 +718,7 @@ pub async fn upload_worker(
                     }
                 }
             };
+            sent_size = file.stream_position().await.unwrap();
             if let Ok(mut message) = message {
                 if let Err(err) = message.delete().await {
                     eprintln!("Failed to delete uploading message: {:?}", err);
@@ -761,6 +763,9 @@ pub async fn upload_worker(
                     };
                 }
             }
+            if sent_size >= total_size {
+                break;
+            }
         }
         drop(file);
         if success {