Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 6 additions & 1 deletion docs/core-protocol.md
Original file line number Diff line number Diff line change
Expand Up @@ -320,7 +320,12 @@ responses are suppressed:
complete, `cleaned` after an allocation-free error or successful compensating
cleanup, or `failed` when cleanup remains unresolved. `session_allocation_unresolved`
also requires `failed`: a lost or malformed POST response does not prove that no
seat was allocated. Sending a response,
seat was allocated. `session_allocation_recovery_required` means an earlier
allocation record blocked admission before POST. It settles that new request as
`cleaned`, while the original record still blocks allocation until the core can
verify its outcome. Discovery includes a recorded origin omitted by the regional
list when it is the original account's provider endpoint or a canonical NVIDIA
queue zone. Sending a response,
clearing a local request ID, or requesting cancellation is not settlement.
An admission `busy` response means no worker was admitted and is not followed
by settlement; Qt tracks retries until they are cancelled or admitted.
Expand Down
143 changes: 106 additions & 37 deletions native/opennow-core/src/cloudmatch.rs
Original file line number Diff line number Diff line change
Expand Up @@ -158,6 +158,35 @@ impl UnresolvedAllocation {
&& self.provider_code.len() <= 1024
&& self.session_id.as_deref().is_none_or(valid_session_id)
}

fn matches(&self, auth: &AuthSession, device_id: &str) -> bool {
self.owner.0 == auth.provider.idp_id
&& self.owner.1 == auth.user.user_id
&& self.provider_code == auth.provider.code
&& self.device_id == device_id
&& self.provider_base == crate::gfn::effective_provider_url(&auth.provider)
}

fn verified_base(&self, auth: &AuthSession) -> Option<Url> {
let base = trusted_cloudmatch_base(&self.allocation_base).ok()?;
if trusted_cloudmatch_base(&self.provider_base).ok().as_ref() == Some(&base) {
return Some(base);
}
// The free-tier queue selector can allocate in a zone omitted from
// serverInfo. Use the same canonical NVIDIA origin check as creation.
if auth.provider.idp_id == crate::gfn::DEFAULT_IDP_ID
&& auth.provider.code.eq_ignore_ascii_case("NVIDIA")
&& base
.host_str()
.and_then(|host| host.strip_suffix(".cloudmatchbeta.nvidiagrid.net"))
.and_then(|zone| crate::queue_servers::zone_url(&zone.to_ascii_uppercase()))
.as_deref()
== Some(base.as_str())
{
return Some(base);
}
None
}
}

struct VerifiedCleanup {
Expand Down Expand Up @@ -375,7 +404,10 @@ impl CloudMatchService {
{
return Err(allocation_in_progress());
}
return Err(unresolved_allocation());
return Err(ServiceError {
code: "session_allocation_recovery_required",
..unresolved_allocation()
});
}
Ok(CreateAdmission {
service: self,
Expand Down Expand Up @@ -1213,7 +1245,20 @@ impl CloudMatchService {
let requested =
recovery_region.map_or_else(|| requested_streaming_base(params, settings, auth), Ok)?;
let headers = cloudmatch_headers(session_token(auth), device_id)?;
let unresolved = self
.unresolved
.lock()
.expect("CloudMatch unresolved state poisoned")
.clone()
.filter(|record| record.matches(auth, device_id));
let mut bases = vec![requested.clone()];
if let Some(base) = unresolved
.as_ref()
.and_then(|record| record.verified_base(auth))
&& base != requested
{
bases.push(base);
}
let server_info_url = requested
.join("v2/serverInfo")
.map_err(|_| invalid("Invalid server-info URL"))?;
Expand Down Expand Up @@ -1282,16 +1327,7 @@ impl CloudMatchService {
.collect()
})?;
let owner = (auth.provider.idp_id.clone(), auth.user.user_id.clone());
let unresolved = self
.unresolved
.lock()
.expect("CloudMatch unresolved state poisoned")
.clone();
if let Some(record) = unresolved
&& record.owner == owner
&& record.provider_code == auth.provider.code
&& record.provider_base == crate::gfn::effective_provider_url(&auth.provider)
&& record.device_id == device_id
&& complete
&& record.session_id.as_ref().map_or_else(
|| sessions.is_empty(),
Expand Down Expand Up @@ -3580,13 +3616,13 @@ mod tests {
);
assert_eq!(
service.admit_create().err().unwrap().code,
"session_allocation_unresolved"
"session_allocation_recovery_required"
);
drop(service);
let restarted = CloudMatchService::with_cleanup_path(Client::new(), path);
assert_eq!(
restarted.admit_create().err().unwrap().code,
"session_allocation_unresolved"
"session_allocation_recovery_required"
);
assert_eq!(
restarted.finish_create("unrelated", true).unwrap_err().code,
Expand Down Expand Up @@ -3687,12 +3723,12 @@ mod tests {
assert!(service.active()["session"].is_null());
assert_eq!(
service.admit_create().err().unwrap().code,
"session_allocation_unresolved"
"session_allocation_recovery_required"
);
let restarted = CloudMatchService::with_cleanup_path(Client::new(), path);
assert_eq!(
restarted.admit_create().err().unwrap().code,
"session_allocation_unresolved"
"session_allocation_recovery_required"
);
}
}
Expand All @@ -3709,20 +3745,29 @@ mod tests {
"wrong-device",
"wrong-provider",
"forged-route",
"queue-absent",
"queue-present",
"queue-unreachable",
"queue-non-nvidia",
"partial",
"malformed",
] {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("pending-session-cleanup.json");
let auth = conflict_auth();
let mut auth = conflict_auth();
if scenario.starts_with("queue-") && scenario != "queue-non-nvidia" {
auth.provider.idp_id = crate::gfn::DEFAULT_IDP_ID.into();
}
let record = UnresolvedAllocation {
owner: (auth.provider.idp_id.clone(), auth.user.user_id.clone()),
provider_code: auth.provider.code.clone(),
provider_base: crate::gfn::effective_provider_url(&auth.provider),
allocation_base: if scenario == "forged-route" {
"https://attacker.example".into()
} else {
DEFAULT_STREAMING_BASE.trim_end_matches('/').into()
allocation_base: match scenario {
"forged-route" => "https://attacker.example".into(),
scenario if scenario.starts_with("queue-") => {
"https://np-usw-01.cloudmatchbeta.nvidiagrid.net".into()
}
_ => DEFAULT_STREAMING_BASE.trim_end_matches('/').into(),
},
device_id: "device".into(),
session_id: scenario.starts_with("known-").then(|| "seat".into()),
Expand All @@ -3732,23 +3777,36 @@ mod tests {
"other-seat" | "known-absent-among-other-seats" => {
json!([{"sessionId":"unrelated-seat","status":3}])
}
"known-present" => json!([{"sessionId":"seat","status":3}]),
"known-present" | "queue-present" => json!([{"sessionId":"seat","status":3}]),
"malformed" => json!([{"sessionId":"missing-status"}]),
_ => json!([]),
};
let (base, server) = session_server(
vec![
(
if scenario == "partial" { 503 } else { 200 },
json!({"metaData":[]}),
),
(
200,
json!({"requestStatus":{"statusCode":1},"sessions":sessions}),
),
],
|_| {},
);
let mut replies = vec![
(
if scenario == "partial" { 503 } else { 200 },
json!({"metaData":[]}),
),
(
200,
json!({"requestStatus":{"statusCode":1},"sessions":sessions}),
),
];
if scenario.starts_with("queue-") && scenario != "queue-non-nvidia" {
replies.push((
if scenario == "queue-unreachable" {
503
} else {
200
},
json!({"requestStatus":{"statusCode":1},"sessions":[]}),
));
}
let expected_requests = replies.len();
let request_count = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
let server_count = request_count.clone();
let (base, server) = session_server(replies, move |_| {
server_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
});
let mut service = CloudMatchService::with_cleanup_path(Client::new(), path.clone());
service.set_test_control_base(base);
let mut current = auth.clone();
Expand All @@ -3768,14 +3826,22 @@ mod tests {
"device"
},
);
if matches!(scenario, "partial" | "malformed") {
if matches!(scenario, "partial" | "malformed" | "queue-unreachable") {
assert_eq!(result.unwrap_err().code, "session_discovery_failed");
} else {
result.unwrap();
}
assert_eq!(
request_count.load(std::sync::atomic::Ordering::Relaxed),
expected_requests,
"{scenario}"
);
let received = server.join().unwrap();
assert!(received.iter().all(|request| request.starts_with("GET ")));
let resolved = matches!(scenario, "absent" | "known-absent-among-other-seats");
let resolved = matches!(
scenario,
"absent" | "known-absent-among-other-seats" | "queue-absent"
);
assert_eq!(service.admit_create().is_ok(), resolved, "{scenario}");
assert_eq!(
!path.with_file_name("unresolved-allocation.json").exists(),
Expand Down Expand Up @@ -4291,7 +4357,7 @@ mod tests {
assert!(service.fresh.lock().unwrap().is_none());
assert_eq!(
service.admit_create().err().unwrap().code,
"session_allocation_unresolved"
"session_allocation_recovery_required"
);
let mut service = CloudMatchService::new(client.clone());
assert!(
Expand Down Expand Up @@ -4333,7 +4399,10 @@ mod tests {
assert!(service.allocation_admission.try_lock().is_ok());
assert!(service.fresh.lock().unwrap().is_none());
if code == "session_allocation_unresolved" {
assert_eq!(service.admit_create().err().unwrap().code, code);
assert_eq!(
service.admit_create().err().unwrap().code,
"session_allocation_recovery_required"
);
assert_eq!(service.finish_create("", false).unwrap_err().code, code);
service = CloudMatchService::new(client.clone());
} else {
Expand Down
52 changes: 45 additions & 7 deletions native/opennow-core/src/gfn.rs
Original file line number Diff line number Diff line change
Expand Up @@ -38,7 +38,7 @@ mod routing_tests;
#[cfg(test)]
mod store_launch_tests;

const DEFAULT_IDP_ID: &str = "PDiAhv2kJTFeQ7WOPqiQ2tRZ7lGhR2X11dXvM4TZSxg";
pub(crate) const DEFAULT_IDP_ID: &str = "PDiAhv2kJTFeQ7WOPqiQ2tRZ7lGhR2X11dXvM4TZSxg";
const DEFAULT_STREAMING_URL: &str = "https://prod.cloudmatchbeta.nvidiagrid.net/";
// Alliance `prod.*` discovery endpoints are geo-steered: they resolve to the
// nearest regional PoP from inside the partner footprint (via VPN or local
Expand Down Expand Up @@ -3293,7 +3293,7 @@ fn public_game_to_info(item: &Value) -> Option<Value> {
})
.unwrap_or_else(|| "Unknown".to_owned());
let image_url = steam_id.as_ref().map(|value| {
format!("https://cdn.cloudflare.steamstatic.com/steam/apps/{value}/header.jpg")
format!("https://cdn.cloudflare.steamstatic.com/steam/apps/{value}/library_600x900_2x.jpg")
});
let hero_image_url = steam_id.as_ref().map(|value| {
format!("https://cdn.cloudflare.steamstatic.com/steam/apps/{value}/library_hero.jpg")
Expand Down Expand Up @@ -3340,15 +3340,40 @@ fn image_values(value: &Value, width: u32) -> Vec<String> {
let trimmed = value.trim();
if trimmed.is_empty() {
None
} else if trimmed.contains("img.nvidiagrid.net") {
Some(format!("{trimmed};f=jpg;w={width}"))
} else {
Some(trimmed.to_owned())
Some(sized_artwork_url(trimmed, width))
}
})
.collect()
}

fn sized_artwork_url(source: &str, width: u32) -> String {
let Ok(mut url) = url::Url::parse(source) else {
return source.to_owned();
};
if url.host_str() != Some("img.nvidiagrid.net") {
return source.to_owned();
}
let path = url.path();
let Some((directory, file)) = path.rsplit_once('/') else {
return source.to_owned();
};
let mut parts = file.split(';');
let mut sized = format!("{directory}/{}", parts.next().unwrap_or_default());
for part in parts {
let key = part.split('=').next().unwrap_or_default();
if !matches!(key, "f" | "w" | "h" | "dpr") {
sized.push(';');
sized.push_str(part);
}
}
// JPEG is available in every supported Qt package. Keep the CDN's
// output dimensions independent of any older modifiers on the source.
sized.push_str(&format!(";f=jpg;w={width}"));
url.set_path(&sized);
url.into()
}

fn first_image(images: &Value, keys: &[&str], width: u32) -> Option<String> {
keys.iter()
.find_map(|key| image_values(&images[*key], width).into_iter().next())
Expand Down Expand Up @@ -5318,7 +5343,7 @@ pub(crate) mod tests {
}

#[test]
fn public_catalog_mapping_matches_electron_contract() {
fn public_catalog_mapping_preserves_launch_identity_and_uses_portrait_art() {
let game = public_game_to_info(&json!({
"id":"ignored", "title":"Portal 2", "status":"AVAILABLE",
"steamUrl":"https://store.steampowered.com/app/620/Portal_2/", "store":"Steam"
Expand All @@ -5331,11 +5356,24 @@ pub(crate) mod tests {
game["imageUrl"]
.as_str()
.unwrap()
.contains("/620/header.jpg")
.contains("/620/library_600x900_2x.jpg")
);
assert!(public_game_to_info(&json!({"title":"Gone", "status":"MAINTENANCE"})).is_none());
}

#[test]
fn nvidia_artwork_replaces_old_resize_options_and_keeps_query_parameters() {
let source = "https://img.nvidiagrid.net/apps/game%20art/GAME_BOX_ART_A.jpg;w=90;h=120;dpr=1;f=webp?locale=en";
let resized = sized_artwork_url(source, 900);
assert_eq!(
resized,
"https://img.nvidiagrid.net/apps/game%20art/GAME_BOX_ART_A.jpg;f=jpg;w=900?locale=en"
);
assert_eq!(sized_artwork_url(&resized, 900), resized);
let external = "https://example.com/img.nvidiagrid.net/GAME_BOX_ART.jpg;w=90";
assert_eq!(sized_artwork_url(external, 900), external);
}

#[test]
fn account_library_mapping_preserves_launch_and_ownership() {
let game = app_to_game(&json!({
Expand Down
Loading
Loading