joey/Aurora-Print
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Added Chrome Job Profiling and Handling

Browse source
This commit is contained in:
Joey Pillunat 2025-10-24 16:55:33 +02:00
parent 5b99621044
commit e4e454960e
5 changed files with 90 additions and 40 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Core/chromium/mod.rs
View file

@ -4,6 +4,7 @@ use crate::state::{SharedState, ChromiumPhase};
mod download;
pub mod utils;
pub mod profiles;
pub const CACHE_DIR: &str = "runtime/chrome-cache";

21
Core/chromium/profiles.rs Normal file
View file

@ -0,0 +1,21 @@
use std::{fs, io, path::{Path, PathBuf}};
pub fn job_profiles_root(exe_dir: &Path) -> PathBuf {
exe_dir.join("runtime").join("chrome-profiles")
}
pub fn create_job_profile(exe_dir: &Path, job_id: &str) -> io::Result<PathBuf> {
let root = job_profiles_root(exe_dir);
fs::create_dir_all(&root)?;
let p = root.join(format!("job-{}", job_id));
fs::create_dir_all(&p)?;
Ok(p)
}
/// Baut die Job-spezifischen Chrome-Args: Basis + user-data-dir + auto RDP-Port
pub fn build_job_args(base: &[String], profile_dir: &Path) -> Vec<String> {
let mut args = base.to_vec();
args.push(format!("--user-data-dir={}", profile_dir.display()));
args.push("--remote-debugging-port=0".to_string());
args
}

2
Core/chromium/utils.rs
View file

@ -39,4 +39,4 @@ fn sanitize_path(name: &str) -> PathBuf {
}
}
clean
}
}

47
Core/headless/mod.rs
View file

@ -62,6 +62,7 @@ impl HeadlessManager {
let page = self.browser.new_page("about:blank").await?;
Ok(PageHandle { page })
}
}
impl PageHandle {
@ -198,48 +199,60 @@ impl PageHandle {
}
}
pub async fn run_test(ip: &str, log: broadcast::Sender<String>) -> Result<(), Box<dyn std::error::Error>> {
let _ = log.send(format!("[Headless] Starte Test für {ip}"));
/// Startet einen Setup-Job mit eigenem Chrome-Profilverzeichnis.
/// `profile_dir` zeigt auf z. B. runtime/chrome-profiles/job-<id>
pub async fn run_test(
ip: &str,
log: broadcast::Sender<String>,
profile_dir: &Path,
) -> Result<(), Box<dyn std::error::Error>> {
log.send(format!("[Headless] Starte Test für {ip}")).ok();
// Config + Chrome-Binärdatei laden
let exe_dir = std::env::current_exe()?.parent().unwrap().to_path_buf();
let cfg = crate::config::read_config(&exe_dir)?;
let chrome_exe = std::path::Path::new(&cfg.chrome.path);
log.send(format!("[Headless] Chrome: {}", chrome_exe.display())).ok();
let _ = log.send(format!("[Headless] Chrome: {}", chrome_exe.display()));
let manager = HeadlessManager::new(chrome_exe, &cfg.chrome.args).await?;
// Basis-Args aus Config + Job-spezifische Isolation
let mut args = cfg.chrome.args.clone();
args.push(format!("--user-data-dir={}", profile_dir.display()));
args.push("--remote-debugging-port=0".to_string());
// Browser starten (mit Job-Args) und neue Seite öffnen
let manager = crate::headless::HeadlessManager::new(chrome_exe, &args).await?;
let page = manager.new_page().await?;
page.goto("https://192.168.178.240/hp/device/SignIn/Index").await?;
// --- Login ---
page.goto(&format!("https://{}/hp/device/SignIn/Index", ip)).await?;
page.wait_for_selector("#PasswordTextBox", 5000).await?;
let _ = log.send("PasswordTextBox gefunden".to_string());
log.send("PasswordTextBox gefunden".to_string()).ok();
page.type_text("#PasswordTextBox", "Pa55w.rt").await?;
let _ = log.send("Passwort erfolgreich eingetragen".to_string());
log.send("Passwort erfolgreich eingetragen".to_string()).ok();
page.wait_for_selector("#signInOk", 5000).await?;
let _ = log.send("Login-Button gefunden, klicke …".to_string());
log.send("Login-Button gefunden, klicke …".to_string()).ok();
page.click_and_wait_navigation("#signInOk", 15_000).await?;
let _ = log.send("Login erfolgreich, warte auf Menü".to_string());
log.send("Login erfolgreich, warte auf Menü".to_string()).ok();
page.wait_for_dom_quiet(8_000).await?;
page.goto("https://192.168.178.240/hp/device/SleepSchedule/Index").await?;
// --- Sleep Schedule setzen ---
page.goto(&format!("https://{}/hp/device/SleepSchedule/Index", ip)).await?;
page.wait_for_selector("#SleepDelayTimeLimit", 5000).await?;
let _ = log.send("Eingabefeld 'SleepDelayTimeLimit' gefunden".to_string());
log.send("Eingabefeld 'SleepDelayTimeLimit' gefunden".to_string()).ok();
page.set_input_value_by_id("SleepDelayTimeLimit", "15").await?;
let _ = log.send("SleepDelayTimeLimit = 15 eingetragen".to_string());
log.send("SleepDelayTimeLimit = 15 eingetragen".to_string()).ok();
page.wait_for_selector("#FormButtonSubmit", 5000).await?;
let _ = log.send("Submit-Button gefunden, sende Formular …".to_string());
log.send("Submit-Button gefunden, sende Formular …".to_string()).ok();
page.click_and_wait_navigation("#FormButtonSubmit", 15_000).await?;
let _ = log.send("Formular erfolgreich gesendet ✅".to_string());
log.send("Formular erfolgreich gesendet ✅".to_string()).ok();
page.wait_for_dom_quiet(8_000).await?;
Ok(())
}

59
Core/web_server/mod.rs
View file

@ -14,6 +14,7 @@ use axum::{
routing::{get, post},
Router,
};
use axum::Json as AxumJson;
use futures::StreamExt;
use serde::{Deserialize, Serialize};
use tokio::{sync::{broadcast, Mutex}};
@ -22,9 +23,12 @@ use tokio_stream::wrappers::BroadcastStream;
use tower_http::services::ServeDir;
use uuid::Uuid;
use assets::{DEFAULT_APP_JS, DEFAULT_INDEX_HTML, DEFAULT_STYLES_CSS};
use crate::chromium::profiles;
use crate::{headless, state::SharedState};
use assets::{DEFAULT_APP_JS, DEFAULT_INDEX_HTML, DEFAULT_STYLES_CSS};
const WEB_DIR: &str = "web";
fn exe_dir() -> PathBuf {
@ -65,41 +69,57 @@ struct StartResponse {
job_id: String,
}
#[derive(Deserialize)]
struct LogsQuery {
job: String,
}
async fn start_job(
axum::extract::State(st): axum::extract::State<HttpState>,
Json(req): Json<StartRequest>,
) -> axum::Json<StartResponse> {
use axum::Json as AxumJson;
) -> AxumJson<StartResponse> {
let ip = req.ip.trim().to_string();
// neuen Job anlegen
// Neuen Job anlegen
let job_id = uuid::Uuid::new_v4().to_string();
let (tx, _rx) = tokio::sync::broadcast::channel::<String>(200);
{
// in Registry eintragen
let mut map = st.jobs.lock().await;
map.insert(job_id.clone(), tx.clone());
}
// Klone für den Task
// Profilordner erzeugen (unter <exe>/runtime/chrome-profiles/job-<id>)
let exe_dir = exe_dir(); // du hast die Funktion schon
let profile_dir = profiles::create_job_profile(&exe_dir, &job_id)
.expect("profile dir create failed");
let job_id_for_task = job_id.clone();
let jobs_map = st.jobs.clone();
// Optional: kleiner Delay, damit der Client Zeit hat den SSE-Stream zu verbinden
tokio::spawn(async move {
sleep(Duration::from_millis(500)).await;
tx.send(format!("[Job {job_id_for_task}] Starte Setup für {ip}")).ok();
use tokio::time::{sleep, Duration};
sleep(Duration::from_millis(250)).await;
// WICHTIG: Ergebnis NICHT in Variable halten, sondern sofort matchen,
// damit kein non-Send Error über das spätere .await (Mutex) "lebt".
if let Err(e) = crate::headless::run_test(&ip, tx.clone()).await {
tx.send(format!("[Job {job_id_for_task}] ❌ Fehler: {e}")).ok();
} else {
tx.send(format!("[Job {job_id_for_task}] ✅ Fertig")).ok();
tx.send(format!("[Job {job_id_for_task}] starte Setup für {ip}")).ok();
// --- Wichtig: Ergebnis sofort in String-Nachricht umwandeln,
// damit kein `Box<dyn Error>` über ein späteres .await "lebt".
let result_msg = match crate::headless::run_test(&ip, tx.clone(), &profile_dir).await {
Ok(_) => format!("[Job {job_id_for_task}] ✅ fertig"),
Err(e) => format!("[Job {job_id_for_task}] ❌ fehler: {e}"),
};
tx.send(result_msg).ok();
// --- ab hier existiert kein non-Send Error mehr
// Cleanup: Profilordner löschen (optional)
sleep(Duration::from_millis(250)).await;
if let Err(e) = std::fs::remove_dir_all(&profile_dir) {
tx.send(format!("[Job {job_id_for_task}] ⚠ cleanup fehlgeschlagen: {e}")).ok();
}
// Erst NACH dem match den Mutex awaiten -> der Error ist schon gedroppt
// Job deregistrieren
let mut m = jobs_map.lock().await;
m.remove(&job_id_for_task);
});
@ -107,11 +127,6 @@ async fn start_job(
AxumJson(StartResponse { job_id })
}
#[derive(Deserialize)]
struct LogsQuery {
job: String,
}
async fn stream_logs(
AxumState(st): AxumState<HttpState>,
Query(q): Query<LogsQuery>,