super-sideloader/src/backend/developer/client.rs (ccef2d0)

client.rs

use crate::backend::adi::{grandslam_device, selected_adi_proxy};
use crate::backend::developer::keychain::{token_is_near_expiry, DeveloperAccountKeychainSession};
use crate::backend::{BackendError, BackendResult};
use crate::domain::{AdiBackendKind, MachineIdentity};
use grandslam::http_session::AnisetteHTTPSession;
use grandslam::AuthenticatedHTTPSession;
use std::future::Future;
use std::pin::Pin;
use xcode::{XcodeSession, XCODE_BUNDLE_INFORMATION, XCODE_TOKEN_IDENTIFIER};

#[derive(Clone, Debug)]
pub(crate) struct DeveloperSessionConfig {
    pub(crate) adi_backend: AdiBackendKind,
    pub(crate) machine_identity: MachineIdentity,
    pub(crate) android_adi_identifier: String,
}

pub(crate) struct DeveloperApiSessionResult<T> {
    pub(crate) value: T,
    pub(crate) keychain_session: DeveloperAccountKeychainSession,
}

pub(crate) async fn with_developer_session<T, F>(
    config: DeveloperSessionConfig,
    session: DeveloperAccountKeychainSession,
    action: F,
) -> BackendResult<DeveloperApiSessionResult<T>>
where
    F: for<'session> FnOnce(
        &'session XcodeSession<'session, 'session>,
    ) -> Pin<Box<dyn Future<Output = BackendResult<T>> + 'session>>,
{
    let proxy = selected_adi_proxy(config.adi_backend, &config.android_adi_identifier)?;
    let http_session = grandslam::http_session(
        grandslam_device(&config.machine_identity),
        XCODE_BUNDLE_INFORMATION,
    )
    .await
    .map_err(|error| {
        BackendError::Network(format!("Failed to create Apple developer session: {error}"))
    })?;
    let anisette_session = AnisetteHTTPSession::new(http_session, proxy.as_ref());
    let authenticated_session = AuthenticatedHTTPSession::new(
        anisette_session,
        session.auth_token.clone(),
        session.heartbeat_token.clone(),
    );

Ok(DeveloperApiSessionResult {
        value,
        keychain_session,
    })
}

apple-crates

Refactor super-sideloader code and finish up the UI/UX