// Copyright 2022-2026 The Jujutsu Authors//// Licensed under the Apache License, Version 2.0 (the "License");// you may not use this file except in compliance with the License.// You may obtain a copy of the License at//// https://www.apache.org/licenses/LICENSE-2.0//// Unless required by applicable law or agreed to in writing, software// distributed under the License is distributed on an "AS IS" BASIS,// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.// See the License for the specific language governing permissions and// limitations under the License.use std::io;use std::path::Path;use std::sync::Mutex;use std::time::Duration;use std::time::Instant;use crossterm::terminal::Clear;use crossterm::terminal::ClearType;use jj_lib::repo_path::RepoPath;use crate::text_util;use crate::ui::OutputGuard;use crate::ui::ProgressOutput;use crate::ui::Ui;pub const UPDATE_HZ: u32 = 30;pub const INITIAL_DELAY: Duration = Duration::from_millis(250);pub struct ProgressWriter<'a> { prefix: &'a str, guard: Option<OutputGuard>, output: ProgressOutput<io::Stderr>, next_display_time: Instant,}// Callers call `display` every time they have new progress, and this will// intermittently print the message synchronously, discarding too-frequent// updates. There is an initial delay to avoid printing anything on fast// commands. For example, `jj status` may be fast or slow depending on// repository size, and in slow runs the progress updates help users see that jj// is working.//// This deliberately doesn't try to be too smart about when to display progress,// such as trying to display the latest message. Printing synchronously without// any delay to a terminal would be a bottleneck; asynchronous output would both// be complex due to threading, and also need to address callers that have their// own output (for example, commit signing may subprocess and prompt for// passphrases).//// When something is slow, this means the displayed message may be from prior to// a slow step. Progress messages are an approximate indicator.impl<'a> ProgressWriter<'a> { pub fn new(ui: &Ui, prefix: &'a str) -> Option<Self> { let output = ui.progress_output()?; // Don't clutter the output during fast operations. let next_display_time = Instant::now() + INITIAL_DELAY; Some(Self { prefix, guard: None, output, next_display_time, }) } pub fn display(&mut self, text: &str) -> io::Result<()> { let now = Instant::now(); if now < self.next_display_time { return Ok(()); } self.next_display_time = now + Duration::from_secs(1) / UPDATE_HZ; if self.guard.is_none() { self.guard = Some( self.output .output_guard(format!("\r{}", Clear(ClearType::CurrentLine))), ); } let line_width = self.output.term_width().map(usize::from).unwrap_or(80); let max_path_width = self.prefix.len() + 1; // Take into account the empty space added after the prefix. let (display_text, _) = text_util::elide_start(text, "...", line_width.saturating_sub(max_path_width)); write!( self.output, "\r{}{} {display_text}", Clear(ClearType::CurrentLine), self.prefix )?; self.output.flush() }}pub fn snapshot_progress(ui: &Ui) -> Option<impl Fn(&RepoPath) + use<>> { let writer = Mutex::new(ProgressWriter::new(ui, "Snapshotting")?); Some(move |path: &RepoPath| { // When the lock is held, skip updates to reduce contention. // // Executing the "future work" above may change this locking. Check // performance with output going to a tty so that writes are slower and // any lock contention is more visible. if let Ok(mut progress) = writer.try_lock() { progress .display(path.to_fs_path_unchecked(Path::new("")).to_str().unwrap()) .ok(); } })}
// Copyright 2022-2026 The Jujutsu Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::io;
use std::path::Path;
use std::sync::Mutex;
use std::time::Duration;
use std::time::Instant;
use crossterm::terminal::Clear;
use crossterm::terminal::ClearType;
use jj_lib::repo_path::RepoPath;
use crate::text_util;
use crate::ui::OutputGuard;
use crate::ui::ProgressOutput;
use crate::ui::Ui;
pub const UPDATE_HZ: u32 = 30;
pub const INITIAL_DELAY: Duration = Duration::from_millis(250);
pub struct ProgressWriter<'a> {
prefix: &'a str,
guard: Option<OutputGuard>,
output: ProgressOutput<io::Stderr>,
next_display_time: Instant,
}
// Callers call `display` every time they have new progress, and this will
// intermittently print the message synchronously, discarding too-frequent
// updates. There is an initial delay to avoid printing anything on fast
// commands. For example, `jj status` may be fast or slow depending on
// repository size, and in slow runs the progress updates help users see that jj
// is working.
//
// This deliberately doesn't try to be too smart about when to display progress,
// such as trying to display the latest message. Printing synchronously without
// any delay to a terminal would be a bottleneck; asynchronous output would both
// be complex due to threading, and also need to address callers that have their
// own output (for example, commit signing may subprocess and prompt for
// passphrases).
//
// When something is slow, this means the displayed message may be from prior to
// a slow step. Progress messages are an approximate indicator.
impl<'a> ProgressWriter<'a> {
pub fn new(ui: &Ui, prefix: &'a str) -> Option<Self> {
let output = ui.progress_output()?;
// Don't clutter the output during fast operations.
let next_display_time = Instant::now() + INITIAL_DELAY;
Some(Self {
prefix,
guard: None,
output,
next_display_time,
})
}
pub fn display(&mut self, text: &str) -> io::Result<()> {
let now = Instant::now();
if now < self.next_display_time {
return Ok(());
}
self.next_display_time = now + Duration::from_secs(1) / UPDATE_HZ;
if self.guard.is_none() {
self.guard = Some(
self.output
.output_guard(format!("\r{}", Clear(ClearType::CurrentLine))),
);
}
let line_width = self.output.term_width().map(usize::from).unwrap_or(80);
let max_path_width = self.prefix.len() + 1; // Take into account the empty space added after the prefix.
let (display_text, _) =
text_util::elide_start(text, "...", line_width.saturating_sub(max_path_width));
write!(
self.output,
"\r{}{} {display_text}",
Clear(ClearType::CurrentLine),
self.prefix
)?;
self.output.flush()
}
}
pub fn snapshot_progress(ui: &Ui) -> Option<impl Fn(&RepoPath) + use<>> {
let writer = Mutex::new(ProgressWriter::new(ui, "Snapshotting")?);
Some(move |path: &RepoPath| {
// When the lock is held, skip updates to reduce contention.
//
// Executing the "future work" above may change this locking. Check
// performance with output going to a tty so that writes are slower and
// any lock contention is more visible.
if let Ok(mut progress) = writer.try_lock() {
progress
.display(path.to_fs_path_unchecked(Path::new("")).to_str().unwrap())
.ok();
}
})
}