https://github.com/ppy/osu/pull/28900/checks?check_run_id=27652166871
This is an attempt. Going frame-by-frame I noticed that there's one
frame in which the text is loaded but the
FillFlowContainer/GridContainer haven't properly validated so the text
is not positioned correctly (it's overflowing the panel to the left). If
the cursor is moved at this exact time, then it may not be properly
positioned for the following assertion, even though it is _somewhere_ on
the panel.
If the above is the case, then this is a known o!f issue, but not a
simple one to solve.
I haven't reproed this locally.
Closes https://github.com/ppy/osu/issues/28938.
This is related to reloading the composer on timing point changes in
scrolling rulesets. The lack of unsubscription from this would cause
blueprints to be created for disposed composers via the
`hitObjectAdded()` flow.
The following line looks as if a sync load should be forced on a newly
created placement blueprint:
da4d37c4ad/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs (L364)
however, it is not the case if the parent
(`placementBlueprintContainer`) is disposed, which it would be in this
case. Therefore, the blueprint stays `NotLoaded` rather than `Ready`,
therefore it never receives its DI dependencies, therefore it dies on
an `EditorBeatmap` nullref.
https://github.com/ppy/osu/actions/runs/9985890747/job/27597501295
In this case, the settings overlay is taking a very long time to load
(on a background thread), and pops in when it finishes loading because
it's been requested to open.
The opens the settings overlay, closes it (by pressing escape, this does
not actually close it because it's not loaded yet), and then enters song
select by pressing 'P' 3 times. The settings overlay finishes loading at
just the right opportune moment to eat one of the 'P' key presses.
This is the first half of a change that *may* fix
https://github.com/ppy/osu/issues/26338 (it definitely fixes *one case*
where the issue happens, but I'm not sure if it will cover all of them).
As described in the issue thread, using the `jti` claim from the JWT
used for authorisation seemed like a decent idea. However, upon closer
inspection the scheme falls over badly in a specific scenario where:
1. A client instance connects to spectator server using JWT A.
2. At some point, JWT A expires, and is silently rotated by the game in
exchange for JWT B.
The spectator server knows nothing of this, and continues to only
track JWT A, including the old `jti` claim in said JWT.
3. At some later point, the client's connection to one of the spectator
server hubs drops out. A reconnection is automatically attempted,
*but* it is attempted using JWT B.
The spectator server was not aware of JWT B until now, and said JWT
has a different `jti` claim than the old one, so to the spectator
server, it looks like a completely different client connecting, which
boots the user out of their account.
This PR adds a per-session GUID which is sent in a HTTP header on every
connection attempt to spectator server. This GUID will be used instead
of the `jti` claim in JWTs as a persistent identifier of a single user's
single lazer session, which bypasses the failure scenario described
above.
I don't think any stronger primitive than this is required. As far as I
can tell this is as strong a protection as the JWT was (which is to say,
not *very* strong), and doing this removes a lot of weird complexity
that would be otherwise incurred by attempting to have client ferry all
of its newly issued JWTs to the server so that it can be aware of them.
