Function register_server

mserver/MasterService/src/http.rs:205–268

(
    State(state): State<AppState>,
    headers: HeaderMap,
    Json(mut request): Json<RegisterServerRequest>,
)

    path = "/v1/servers/register",
    request_body = RegisterServerRequest,
    responses(
        (status = 200, description = "Registered server row", body = DirectoryServerRecord)
    )
)]
async fn register_server(
    State(state): State<AppState>,
    headers: HeaderMap,
    connect_info: Option<ConnectInfo<SocketAddr>>,
    Json(mut request): Json<RegisterServerRequest>,
) -> Result<Json<DirectoryServerRecord>, (StatusCode, String)> {
    if let Some(ip) = publish_client_ip(&state, &headers, connect_info.as_ref().map(|info| info.0))
    {
        request.server_id = format!("{ip}:{}", request.hostport);
        request.address = ip;
    }
    let server_id = request.server_id.clone();

    let existing = state
        .service
        .get(&server_id)
        .await
        .map_err(|error| internal_error(&error))?;
    let stored_hash = state
        .service
        .server_token_hash(&server_id)
        .await
        .map_err(|error| internal_error(&error))?;
    let provided_token = bearer_token(&headers);
    let token_ok = matches!(
        (&provided_token, &stored_hash),
        (Some(token), Some(hash)) if &service::token_hash(token) == hash
    );

    // Protect an actively-heartbeating, token-held row from takeover by a wrong/missing
    // token (only when enforcement is on). A stale row (silent owner) may be reclaimed,
    // which is the crash-recovery path.
    if state.require_server_token && !token_ok && stored_hash.is_some() {
        let fresh = existing.is_some_and(|row| {
            current_time_millis() - row.last_seen_unix_ms < SERVER_TOKEN_RECOVERY_MS
        });
        if fresh {
            return Err((
                StatusCode::UNAUTHORIZED,
                "missing or invalid server token".to_string(),
            ));
        }
    }

    let mut record = state
        .service
        .register(request, current_time_millis())
        .await
        .map_err(|error| internal_error(&error))?;

    // Issue a token on first registration, and rotate it on an (authorized) takeover; a
    // valid-token heartbeat keeps the existing token.
    if !token_ok {
        let (token, hash) = service::issue_token().map_err(|error| internal_error(&error))?;