ic-query 0.102.0

Internet Computer query library for CloudEngine, NNS, SNS, ICRC, system canisters, and public network metadata
Documentation
//! Module: ic::live::replica_version
//!
//! Responsibility: live Dashboard replica-version URL and wire handling.
//! Does not own: report validation, CLI parsing, provenance projection, or rendering.
//! Boundary: performs one bounded list request or one exact release request.

use super::{LiveIcSource, dashboard_resource_url};
use crate::ic::{
    IcHostError, IcReplicaVersionInfoSourceData, IcReplicaVersionListQuery,
    IcReplicaVersionListRow, IcReplicaVersionListSourceData, IcReplicaVersionSource,
    IcReplicaVersionStatus, IcSourceRequest, source,
};
use serde::Deserialize as SerdeDeserialize;
use url::Url;

impl IcReplicaVersionSource for LiveIcSource {
    fn fetch_replica_version_list<'a>(
        &'a self,
        request: &'a IcSourceRequest,
        query: &'a IcReplicaVersionListQuery,
    ) -> crate::report::SourceFuture<'a, Result<IcReplicaVersionListSourceData, IcHostError>> {
        Box::pin(async move {
            source::validate_replica_version_list_query(query)?;
            let url = replica_version_list_url(&request.endpoint, query)?;
            let wire: DashboardReplicaVersionList = self.fetch_live(url).await?;
            Ok(wire.into_source_data(request, query))
        })
    }

    fn fetch_replica_version_info<'a>(
        &'a self,
        request: &'a IcSourceRequest,
        replica_version_id: &'a str,
    ) -> crate::report::SourceFuture<'a, Result<IcReplicaVersionInfoSourceData, IcHostError>> {
        Box::pin(async move {
            source::validate_replica_version_id(replica_version_id)?;
            let url = replica_version_info_url(&request.endpoint, replica_version_id)?;
            let wire: crate::ic::IcReplicaVersionDetails = self.fetch_live(url).await?;
            Ok(IcReplicaVersionInfoSourceData {
                source: request.clone(),
                release: wire,
            })
        })
    }
}

fn replica_version_list_url(
    endpoint: &str,
    query: &IcReplicaVersionListQuery,
) -> Result<Url, IcHostError> {
    let mut url = dashboard_resource_url(endpoint, &["subnet-replica-versions"])?;
    {
        let mut pairs = url.query_pairs_mut();
        pairs.append_pair("limit", &query.limit.to_string());
        pairs.append_pair("offset", &query.offset.to_string());
        pairs.append_pair("sort_by", "-executed_timestamp_seconds");
        for status in [
            IcReplicaVersionStatus::Executed,
            IcReplicaVersionStatus::Open,
            IcReplicaVersionStatus::Adopted,
        ] {
            pairs.append_pair("include_status", status.as_dashboard_value());
        }
        if let Some(max_proposal_index) = query.max_proposal_index {
            pairs.append_pair("max_proposal_index", &max_proposal_index.to_string());
        }
    }
    Ok(url)
}

fn replica_version_info_url(endpoint: &str, replica_version_id: &str) -> Result<Url, IcHostError> {
    dashboard_resource_url(endpoint, &["subnet-replica-versions", replica_version_id])
}

#[derive(SerdeDeserialize)]
struct DashboardReplicaVersionList {
    data: Vec<IcReplicaVersionListRow>,
    max_proposal_index: u64,
    total_proposals: u64,
}

impl DashboardReplicaVersionList {
    fn into_source_data(
        self,
        request: &IcSourceRequest,
        query: &IcReplicaVersionListQuery,
    ) -> IcReplicaVersionListSourceData {
        IcReplicaVersionListSourceData {
            source: request.clone(),
            query: query.clone(),
            resolved_max_proposal_index: self.max_proposal_index,
            total_proposals: self.total_proposals,
            rows: self.data,
        }
    }
}

#[cfg(test)]
mod tests;