Struct git_protocol::RemoteProgress

source ·

pub struct RemoteProgress<'a> {
    pub action: &'a BStr,
    pub percent: Option<u32>,
    pub step: Option<usize>,
    pub max: Option<usize>,
}

Expand description

The information usually found in remote progress messages as sent by a git server during fetch, clone and push operations.

Fields§

§action: &'a BStr

The name of the action, like “clone”.

§percent: Option<u32>

The percentage to indicate progress, between 0 and 100.

§step: Option<usize>

The amount of items already processed.

§max: Option<usize>

The maximum expected amount of items. step / max * 100 = percent.

Implementations§

source §

impl<'a> RemoteProgress<'a>

source

pub fn from_bytes(line: &[u8]) -> Option<RemoteProgress<'_>>

Parse the progress from a typical git progress line as sent by the remote.

Examples found in repository ?

src/remote_progress.rs (line 57)

    pub fn translate_to_progress(is_error: bool, text: &[u8], progress: &mut impl git_features::progress::Progress) {
        fn progress_name(current: Option<String>, action: &[u8]) -> String {
            match current {
                Some(current) => format!(
                    "{}: {}",
                    current.split_once(':').map_or(&*current, |x| x.0),
                    action.as_bstr()
                ),
                None => action.as_bstr().to_string(),
            }
        }
        if is_error {
            // ignore keep-alive packages sent with 'sideband-all'
            if !text.is_empty() {
                progress.fail(progress_name(None, text));
            }
        } else {
            match RemoteProgress::from_bytes(text) {
                Some(RemoteProgress {
                    action,
                    percent: _,
                    step,
                    max,
                }) => {
                    progress.set_name(progress_name(progress.name(), action));
                    progress.init(max, git_features::progress::count("objects"));
                    if let Some(step) = step {
                        progress.set(step);
                    }
                }
                None => progress.set_name(progress_name(progress.name(), text)),
            };
        }
    }

source

pub fn translate_to_progress(
    is_error: bool,
    text: &[u8],
    progress: &mut impl Progress
)

Parse text, which is interpreted as error if is_error is true, as RemoteProgress and call the respective methods on the given progress instance.

Examples found in repository ?

src/fetch_fn.rs (line 165)

fn setup_remote_progress<P>(progress: &mut P, reader: &mut Box<dyn git_transport::client::ExtendedBufRead + Unpin + '_>)
where
    P: Progress,
    P::SubProgress: 'static,
{
    reader.set_progress_handler(Some(Box::new({
        let mut remote_progress = progress.add_child("remote");
        move |is_err: bool, data: &[u8]| {
            crate::RemoteProgress::translate_to_progress(is_err, data, &mut remote_progress)
        }
    }) as git_transport::client::HandleProgress));
}