Skip to content

armgit / kokon

Public Imported from GitHub
0

Edit photos by describing the change, on your own GPU. A free, open-source alternative to Nano Banana and ChatGPT image editing: photos stay on your computer, no daily limit. One installer for Windows, Mac and Linux sets up the best open model (Qwen-Image 2.1). MCP server for AI agents.

fix: start on a free port when Windows reserves Kokon's ports

Gabriele Lozuponea2703eb94e59
diff --git a/crates/qls-core/src/engine.rs b/crates/qls-core/src/engine.rs
index c4929fa..b1cb58b 100644
--- a/crates/qls-core/src/engine.rs
+++ b/crates/qls-core/src/engine.rs
@@ -827,7 +827,7 @@ impl Engine {
// Whether the running server can use the upscaler (an engine older than MoSR lists the
// file but cannot run it; an external server may lack --hires-upscalers-dir):
// enlargements fall back to Lanczos. Fresh, because the server rescans the folder.
- let client = SdcppClient::new(cfg.server_port);
+ let client = SdcppClient::new(self.server.port());
let caps = client.capabilities(Duration::from_secs(5)).await.ok().or_else(|| self.server.capabilities()).unwrap_or_default();
let esrgan = plan.upscaler.clone().filter(|n| caps.has_upscaler(n, true));
let needs_esrgan = plan.upscale.is_some() || plan.output.area() as f64 > plan.content.area() as f64 * 1.21;
diff --git a/crates/qls-core/src/process.rs b/crates/qls-core/src/process.rs
index d500afb..61d4716 100644
--- a/crates/qls-core/src/process.rs
+++ b/crates/qls-core/src/process.rs
@@ -418,10 +418,13 @@ impl ServerManager {
pub async fn ensure_ready(&self, cfg: &AppConfig) -> Result<Capabilities, AppError> {
let _guard = self.start_lock.lock().await;
let profile = cfg.profile().clone();
- let client = SdcppClient::new(cfg.server_port);
+ // Our server may run on a fallback port (see `launch_port`); otherwise the configured one.
+ let rec = self.read_record().filter(|r| process_alive(r.pid));
+ let port = rec.as_ref().map(|r| r.port).unwrap_or(cfg.server_port);
+ let client = SdcppClient::new(port);
if let Ok(caps) = client.capabilities(Duration::from_secs(3)).await {
- let rec = self.read_record().filter(|r| r.port == cfg.server_port && process_alive(r.pid));
+ let rec = rec.filter(|r| r.port == port);
if caps.model_matches(&profile.diffusion_model) && caps.supports_img_gen() {
let owned = rec.is_some();
if let Some(r) = &rec
@@ -433,7 +436,7 @@ impl ServerManager {
g.state = ServerState::Ready;
g.owned = owned;
g.pid = rec.as_ref().map(|r| r.pid);
- g.port = cfg.server_port;
+ g.port = port;
g.model = Some(caps.model.name.clone());
g.error = None;
g.caps = Some(caps.clone());
@@ -443,30 +446,21 @@ impl ServerManager {
});
return Ok(caps);
}
- // Wrong model on our port.
if let Some(r) = rec {
tracing::info!("restarting owned sd-server (pid {}) for a different model", r.pid);
kill_pid(r.pid);
let _ = std::fs::remove_file(self.record_path());
wait_port_free(&client, Duration::from_secs(15)).await;
} else {
- let e = AppError::new(
- ErrorCode::ServerStartFailed,
- format!("Port {} is used by another stable-diffusion.cpp server with a different model ({}).", cfg.server_port, caps.model.name),
- )
- .suggest("Stop that server or choose another port in Settings.");
- self.set_state(|g| {
- g.state = ServerState::Error;
- g.error = Some(e.clone());
- });
- return Err(e);
+ // Someone else's server with another model: ours starts on a free port.
+ tracing::info!("port {port} is used by another stable-diffusion.cpp server ({}); starting ours on another port", caps.model.name);
}
}
- self.spawn_and_wait(cfg, &profile, &client).await
+ self.spawn_and_wait(cfg, &profile).await
}
- async fn spawn_and_wait(&self, cfg: &AppConfig, profile: &ModelProfile, client: &SdcppClient) -> Result<Capabilities, AppError> {
+ async fn spawn_and_wait(&self, cfg: &AppConfig, profile: &ModelProfile) -> Result<Capabilities, AppError> {
let fail = |e: AppError| {
self.set_state(|g| {
g.state = ServerState::Error;
@@ -483,14 +477,34 @@ impl ServerManager {
if let Some(d) = log_path.parent() {
std::fs::create_dir_all(d).map_err(|e| fail(AppError::io("create the log folder", d, e)))?;
}
+ let mut port = launch_port(cfg.server_port).ok_or_else(|| fail(port_unavailable_error(cfg.server_port)))?;
+ // sd-server exits with code 0 and no log line when it cannot listen (a port reserved
+ // between our check and its bind): one more try on another free port.
+ for attempt in 0..2 {
+ match self.launch(cfg, profile, &exe, &log_path, port).await {
+ Ok(caps) => return Ok(caps),
+ Err(Launch::Failed(e)) => return Err(fail(e)),
+ Err(Launch::NotListening) if attempt == 0 => {
+ tracing::warn!("sd-server exited without listening on port {port}; retrying on another port");
+ port = free_port().ok_or_else(|| fail(port_unavailable_error(port)))?;
+ }
+ Err(Launch::NotListening) => break,
+ }
+ }
+ Err(fail(port_unavailable_error(port)))
+ }
+
+ async fn launch(&self, cfg: &AppConfig, profile: &ModelProfile, exe: &Path, log_path: &Path, port: u16) -> Result<Capabilities, Launch> {
+ let fail = Launch::Failed;
if log_path.exists() {
- let _ = std::fs::rename(&log_path, log_path.with_extension("prev.log"));
+ let _ = std::fs::rename(log_path, log_path.with_extension("prev.log"));
}
- let file = std::fs::File::create(&log_path).map_err(|e| fail(AppError::io("create the server log", &log_path, e)))?;
- let args = build_server_args(cfg, profile);
+ let file = std::fs::File::create(log_path).map_err(|e| fail(AppError::io("create the server log", log_path, e)))?;
+ let run_cfg = AppConfig { server_port: port, ..cfg.clone() };
+ let args = build_server_args(&run_cfg, profile);
tracing::info!("starting {} {}", exe.display(), args.join(" "));
- let mut cmd = std::process::Command::new(&exe);
+ let mut cmd = std::process::Command::new(exe);
cmd.args(&args)
.current_dir(&cfg.sdcpp_dir)
.stdin(std::process::Stdio::null())
@@ -505,25 +519,30 @@ impl ServerManager {
fail(AppError::new(ErrorCode::ServerStartFailed, "Could not launch sd-server.exe.").detail(e.to_string()))
})?;
let pid = child.id();
- let rec = OwnedRecord { pid, port: cfg.server_port, model: profile.model_name(), log: log_path.clone() };
+ let rec = OwnedRecord { pid, port, model: profile.model_name(), log: log_path.to_path_buf() };
let _ = std::fs::write(self.record_path(), serde_json::to_string(&rec).unwrap_or_default());
self.set_state(|g| {
g.state = ServerState::Starting;
g.owned = true;
g.pid = Some(pid);
- g.port = cfg.server_port;
+ g.port = port;
g.error = None;
g.caps = None;
g.started_at = Some(chrono::Utc::now());
});
- self.start_tail(&log_path, false);
+ self.start_tail(log_path, false);
+ let client = SdcppClient::new(port);
let started = Instant::now();
loop {
if let Ok(Some(status)) = child.try_wait() {
tokio::time::sleep(Duration::from_millis(300)).await;
let tail = self.log.tail(40).join("\n");
let _ = std::fs::remove_file(self.record_path());
+ // Code 0 before answering = `svr.listen` failed (it logs "listening on" first).
+ if status.success() {
+ return Err(Launch::NotListening);
+ }
return Err(fail(translate_startup_failure(&format!("{tail}\n(exit status {status})"))));
}
if let Ok(caps) = client.capabilities(Duration::from_secs(2)).await {
@@ -545,6 +564,11 @@ impl ServerManager {
}
}
+ /// The port of the server in use; it can differ from the configured one (`launch_port`).
+ pub fn port(&self) -> u16 {
+ self.inner.lock().unwrap().port
+ }
+
/// Stops the server if this app owns it. Never touches servers it did not start.
pub async fn stop(&self) -> bool {
let _guard = self.start_lock.lock().await;
@@ -647,6 +671,36 @@ async fn wait_port_free(client: &SdcppClient, timeout: Duration) {
}
}
+enum Launch {
+ Failed(AppError),
+ /// Exited with code 0 before answering: the port could not be opened.
+ NotListening,
+}
+
+/// The configured port when it can be opened, otherwise a free one. Windows reserves port
+/// ranges for Hyper-V, WSL and Docker (`netsh interface ipv4 show excludedportrange
+/// protocol=tcp`), different at every boot; binding a reserved port fails with "access denied".
+fn launch_port(configured: u16) -> Option<u16> {
+ match std::net::TcpListener::bind(("127.0.0.1", configured)) {
+ Ok(_) => Some(configured),
+ Err(e) => {
+ let p = free_port();
+ tracing::warn!("port {configured} cannot be opened ({e}); using {p:?}");
+ p
+ }
+ }
+}
+
+/// A port the system reports free right now.
+pub fn free_port() -> Option<u16> {
+ std::net::TcpListener::bind(("127.0.0.1", 0)).and_then(|l| l.local_addr()).map(|a| a.port()).ok()
+}
+
+fn port_unavailable_error(port: u16) -> AppError {
+ AppError::new(ErrorCode::ServerStartFailed, format!("The inference server could not open a network port on this computer (last tried: {port})."))
+ .suggest("Windows can reserve ports for Hyper-V, WSL or Docker. Restart the computer, or set another port in Settings → Performance.")
+}
+
pub fn process_alive(pid: u32) -> bool {
use sysinfo::{Pid, ProcessRefreshKind, ProcessesToUpdate, System};
let mut sys = System::new();
@@ -924,6 +978,17 @@ mod tests {
assert_eq!(u.step, Some((20, 20)));
}
+ #[test]
+ fn launch_port_falls_back_when_the_port_cannot_be_opened() {
+ let taken = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap();
+ let busy = taken.local_addr().unwrap().port();
+ let p = launch_port(busy).unwrap();
+ assert_ne!(p, busy);
+ assert!(std::net::TcpListener::bind(("127.0.0.1", p)).is_ok(), "the fallback is free");
+ let free = free_port().unwrap();
+ assert_eq!(launch_port(free), Some(free), "a free configured port is kept");
+ }
+
#[test]
fn parser_ignores_lines_before_a_job() {
let mut p = ProgressParser::default();
diff --git a/crates/qls-service/src/api.rs b/crates/qls-service/src/api.rs
index 71caa1e..466bda0 100644
--- a/crates/qls-service/src/api.rs
+++ b/crates/qls-service/src/api.rs
@@ -203,7 +203,7 @@ async fn status(State(s): St) -> Json<Value> {
Json(json!({
"service": { "version": APP_VERSION, "pid": std::process::id(), "uptime_s": s.started.elapsed().as_secs() },
"server": {
- "state": srv.state, "owned": srv.owned, "pid": srv.pid, "port": cfg.server_port,
+ "state": srv.state, "owned": srv.owned, "pid": srv.pid, "port": if srv.port > 0 { srv.port } else { cfg.server_port },
"model": srv.model, "model_loaded": srv.state == qls_core::process::ServerState::Ready,
"error": srv.error,
"cancel_generating": srv.capabilities.as_ref().map(|c| c.img_feature("cancel_generating")),
@@ -543,7 +543,7 @@ async fn diagnostics_json(State(s): St) -> ApiResult<Json<Value>> {
.map(|d| d.installed_tag(&cfg.sdcpp_dir).unwrap_or_else(|| "none".into()))
.collect();
let _ = writeln!(text, "Engine release: {} (expected {})", tags.join(", "), catalog::engine_tag());
- let _ = writeln!(text, "State: {:?}, owned: {}, pid: {:?}, port: {}", srv.state, srv.owned, srv.pid, cfg.server_port);
+ let _ = writeln!(text, "State: {:?}, owned: {}, pid: {:?}, port: {}", srv.state, srv.owned, srv.pid, srv.port);
if let Some(e) = &srv.error {
let _ = writeln!(text, "Last error: {} {}", e.message, e.detail.clone().unwrap_or_default());
}
diff --git a/crates/qls-service/src/main.rs b/crates/qls-service/src/main.rs
index 19075e3..dfba8ae 100644
--- a/crates/qls-service/src/main.rs
+++ b/crates/qls-service/src/main.rs
@@ -77,6 +77,21 @@ fn load_or_create_token(dir: &std::path::Path) -> String {
t
}
+/// The port of a kokon-service that answers its ping at the port recorded in service.json.
+async fn running_service() -> Option<u16> {
+ use tokio::io::{AsyncReadExt, AsyncWriteExt};
+ let info: ServiceInfo = serde_json::from_str(&std::fs::read_to_string(service_info_path()).ok()?).ok()?;
+ let ping = async {
+ let mut s = tokio::net::TcpStream::connect(("127.0.0.1", info.port)).await.ok()?;
+ s.write_all(b"GET /api/v1/ping HTTP/1.0\r\nHost: 127.0.0.1\r\n\r\n").await.ok()?;
+ let mut buf = vec![0u8; 256];
+ let n = s.read(&mut buf).await.ok()?;
+ let head = String::from_utf8_lossy(&buf[..n]);
+ (head.starts_with("HTTP/1.") && head.split(' ').nth(1) == Some("200")).then_some(info.port)
+ };
+ tokio::time::timeout(Duration::from_secs(2), ping).await.ok().flatten()
+}
+
pub fn service_info_path() -> PathBuf {
data_dir().join("service.json")
}
@@ -115,15 +130,30 @@ async fn main() {
.and_then(|p| p.parse().ok())
.unwrap_or(cfg.service_port);
- // Single instance: binding the port is the lock. Loopback only.
- let addr = SocketAddr::from(([127, 0, 0, 1], port));
- let listener = match tokio::net::TcpListener::bind(addr).await {
+ // Single instance: a kokon-service answering at the port in service.json. Loopback only.
+ let listener = match tokio::net::TcpListener::bind(SocketAddr::from(([127, 0, 0, 1], port))).await {
Ok(l) => l,
Err(e) => {
- tracing::info!("port {port} busy ({e}); another kokon-service is probably running — exiting");
- return;
+ if let Some(other) = running_service().await {
+ tracing::info!("port {port} busy ({e}); kokon-service is already running on port {other} — exiting");
+ return;
+ }
+ // Reserved by Windows (Hyper-V/WSL/Docker excluded ranges, "access denied") or taken
+ // by another program: any free port. Clients find it in service.json.
+ match tokio::net::TcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).await {
+ Ok(l) => {
+ tracing::warn!("port {port} cannot be opened ({e}); using {}", l.local_addr().map(|a| a.port()).unwrap_or(0));
+ l
+ }
+ Err(e2) => {
+ tracing::error!("port {port} cannot be opened ({e}) and no free port either ({e2}) — exiting");
+ return;
+ }
+ }
}
};
+ let addr = listener.local_addr().unwrap_or_else(|_| SocketAddr::from(([127, 0, 0, 1], port)));
+ let port = addr.port();
let engine = match Engine::new(cfg, &dir) {
Ok(e) => e,