use anyhow::{anyhow, Result};use clap::Clap;use gitoxide_core as core;use std::io::{stderr, stdout, Write}; use gitoxide_core::pack::verify;use options::*; mod options {    use clap::{AppSettings, Clap};    use gitoxide_core as core;    use std::path::PathBuf;     #[derive(Debug, Clap)]    #[clap(name = "gix-plumbing", about = "The git underworld", version = clap::crate_version!())]    #[clap(setting = AppSettings::SubcommandRequired)]    #[clap(setting = AppSettings::ColoredHelp)]    pub struct Args {        #[clap(long, short = "t")]        /// The amount of threads to use for some operations.        ///        /// If unset, or the value is 0, there is no limit and all logical cores can be used.        pub threads: Option<usize>,         /// Display verbose messages and progress information        #[clap(long, short = "v")]        pub verbose: bool,         /// Bring up a terminal user interface displaying progress visually        #[clap(long, conflicts_with("verbose"))]        pub progress: bool,         /// The progress TUI will stay up even though the work is already completed.        ///        /// Use this to be able to read progress messages or additional information visible in the TUI log pane.        #[clap(long, conflicts_with("verbose"), requires("progress"))]        pub progress_keep_open: bool,         /// Determine the format to use when outputting statistics.        #[clap(            long,            short = "f",            default_value = "human",            possible_values(core::OutputFormat::variants())        )]        pub format: core::OutputFormat,         #[clap(subcommand)]        pub cmd: Subcommands,    }     #[derive(Debug, Clap)]    pub enum Subcommands {        /// Create an index from a packfile.        ///        /// This command can also be used to stream packs to standard input or to repair partial packs.        #[clap(setting = AppSettings::ColoredHelp)]        #[clap(setting = AppSettings::DisableVersion)]        PackIndexFromData {            /// Specify how to iterate the pack, defaults to 'verify'            ///            /// Valid values are            ///            ///  **as-is** do not do anything and expect the pack file to be valid as per the trailing hash,            ///  **verify** the input ourselves and validate that it matches with the hash provided in the pack,            ///  **restore** hash the input ourselves and ignore failing entries, instead finish the pack with the hash we computed            #[clap(                long,                short = "i",                default_value = "verify",                possible_values(core::pack::index::IterationMode::variants())            )]            iteration_mode: core::pack::index::IterationMode,             /// Path to the pack file to read (with .pack extension).            ///            /// If unset, the pack file is expected on stdin.            #[clap(long, short = "p")]            pack_path: Option<PathBuf>,             /// The folder into which to place the pack and the generated index file            ///            /// If unset, only informational output will be provided to standard output.            #[clap(parse(from_os_str))]            directory: Option<PathBuf>,        },        /// Verify the integrity of a pack or index file        #[clap(setting = AppSettings::ColoredHelp)]        #[clap(setting = AppSettings::DisableVersion)]        PackExplode {            #[clap(long)]            /// Read written objects back and assert they match their source. Fail the operation otherwise.            ///            /// Only relevant if an object directory is set.            verify: bool,             /// delete the pack and index file after the operation is successful            #[clap(long)]            delete_pack: bool,             /// The amount of checks to run            #[clap(                long,                short = "c",                default_value = "all",                possible_values(core::pack::explode::SafetyCheck::variants())            )]            check: core::pack::explode::SafetyCheck,             /// Compress bytes even when using the sink, i.e. no object directory is specified            ///            /// This helps to determine overhead related to compression. If unset, the sink will            /// only create hashes from bytes, which is usually limited by the speed at which input            /// can be obtained.            #[clap(long)]            sink_compress: bool,             /// The '.pack' or '.idx' file to explode into loose objects            #[clap(parse(from_os_str))]            pack_path: PathBuf,             /// The path into which all objects should be written. Commonly '.git/objects'            #[clap(parse(from_os_str))]            object_path: Option<PathBuf>,        },        /// Verify the integrity of a pack or index file        #[clap(setting = AppSettings::ColoredHelp)]        #[clap(setting = AppSettings::DisableVersion)]        PackVerify {            /// output statistical information about the pack            #[clap(long, short = "s")]            statistics: bool,            /// The algorithm used to verify the pack. They differ in costs.            #[clap(                long,                short = "a",                default_value = "less-time",                possible_values(core::pack::verify::Algorithm::variants())            )]            algorithm: core::pack::verify::Algorithm,             #[clap(long, conflicts_with("re-encode"))]            /// Decode and parse tags, commits and trees to validate their correctness beyond hashing correctly.            ///            /// Malformed objects should not usually occur, but could be injected on purpose or accident.            /// This will reduce overall performance.            decode: bool,             #[clap(long)]            /// Decode and parse tags, commits and trees to validate their correctness, and re-encode them.            ///            /// This flag is primarily to test the implementation of encoding, and requires to decode the object first.            /// Encoding an object after decoding it should yield exactly the same bytes.            /// This will reduce overall performance even more, as re-encoding requires to transform zero-copy objects into            /// owned objects, causing plenty of allocation to occour.            re_encode: bool,             /// The '.pack' or '.idx' file whose checksum to validate.            #[clap(parse(from_os_str))]            path: PathBuf,        },    }} use crate::shared::ProgressRange; fn prepare_and_run<T: Send + 'static>(    name: &str,    verbose: bool,    progress: bool,    progress_keep_open: bool,    range: impl Into<Option<ProgressRange>>,    run: impl FnOnce(Option<prodash::tree::Item>, &mut dyn std::io::Write, &mut dyn std::io::Write) -> Result<T>        + Send        + 'static,) -> Result<T> {    use crate::shared::{self, STANDARD_RANGE};    super::init_env_logger(false);    use git_features::interrupt::{is_triggered, trigger};    match (verbose, progress) {        (false, false) => run(None, &mut stdout(), &mut stderr()),        (true, false) => {            enum Event<T> {                UIDone,                ComputationDone(Result<T>),            };            let progress = prodash::Tree::new();            let sub_progress = progress.add_child(name);            let (tx, rx) = std::sync::mpsc::sync_channel::<Event<T>>(1);            let ui_handle = shared::setup_line_renderer_range(progress, range.into().unwrap_or(STANDARD_RANGE), true);            std::thread::spawn({                let tx = tx.clone();                move || loop {                    std::thread::sleep(std::time::Duration::from_millis(500));                    if is_triggered() {                        tx.send(Event::UIDone).ok();                        break;                    }                }            });            std::thread::spawn(move || {                let res = run(Some(sub_progress), &mut stdout(), &mut stderr());                tx.send(Event::ComputationDone(res)).ok();            });            match rx.recv()? {                Event::UIDone => {                    ui_handle.shutdown_and_wait();                    Err(anyhow!("Operation cancelled by user"))                }                Event::ComputationDone(res) => {                    ui_handle.shutdown_and_wait();                    res                }            }        }        (true, true) | (false, true) => {            enum Event<T> {                UIDone,                ComputationDone(Result<T>, Vec<u8>, Vec<u8>),            };            let progress = prodash::Tree::new();            let sub_progress = progress.add_child(name);            let render_tui = prodash::render::tui(                stdout(),                progress,                prodash::render::tui::Options {                    title: "gitoxide".into(),                    frames_per_second: crate::shared::DEFAULT_FRAME_RATE,                    stop_if_empty_progress: !progress_keep_open,                    throughput: true,                    ..Default::default()                },            )            .expect("tui to come up without io error");            let (tx, rx) = std::sync::mpsc::sync_channel::<Event<T>>(1);            let ui_handle = std::thread::spawn({                let tx = tx.clone();                move || {                    futures_lite::future::block_on(render_tui);                    tx.send(Event::UIDone).ok();                }            });            std::thread::spawn(move || {                // We might have something interesting to show, which would be hidden by the alternate screen if there is a progress TUI                // We know that the printing happens at the end, so this is fine.                let mut out = Vec::new();                let mut err = Vec::new();                let res = run(Some(sub_progress), &mut out, &mut err);                tx.send(Event::ComputationDone(res, out, err)).ok();            });            loop {                match rx.recv()? {                    Event::UIDone => {                        // We don't know why the UI is done, usually it's the user aborting.                        // We need the computation to stop as well so let's wait for that to happen                        trigger();                        continue;                    }                    Event::ComputationDone(res, out, err) => {                        ui_handle.join().ok();                        stdout().write_all(&out)?;                        stderr().write_all(&err)?;                        break res;                    }                }            }        }    }} pub fn main() -> Result<()> {    let Args {        threads: thread_limit,        verbose,        progress,        progress_keep_open,        format,        cmd,    } = Args::parse();    git_features::interrupt::init_handler(std::io::stderr());     match cmd {        Subcommands::PackIndexFromData {            iteration_mode,            pack_path,            directory,        } => prepare_and_run(            "pack-index-from-data",            verbose,            progress,            progress_keep_open,            core::pack::index::PROGRESS_RANGE,            move |progress, out, _err| {                core::pack::index::from_pack(                    pack_path,                    directory,                    git_features::progress::DoOrDiscard::from(progress),                    core::pack::index::Context {                        thread_limit,                        iteration_mode,                        format,                        out,                    },                )            },        ),        Subcommands::PackExplode {            check,            sink_compress,            delete_pack,            pack_path,            object_path,            verify,        } => prepare_and_run(            "pack-explode",            verbose,            progress,            progress_keep_open,            None,            move |progress, _out, _err| {                core::pack::explode::pack_or_pack_index(                    pack_path,                    object_path,                    check,                    progress,                    core::pack::explode::Context {                        thread_limit,                        delete_pack,                        sink_compress,                        verify,                    },                )            },        ),        Subcommands::PackVerify {            path,            algorithm,            decode,            re_encode,            statistics,        } => prepare_and_run(            "pack-verify",            verbose,            progress,            progress_keep_open,            None,            move |progress, out, err| {                let mode = match (decode, re_encode) {                    (true, false) => verify::Mode::Sha1CRC32Decode,                    (true, true) | (false, true) => verify::Mode::Sha1CRC32DecodeEncode,                    (false, false) => verify::Mode::Sha1CRC32,                };                let output_statistics = if statistics { Some(format) } else { None };                verify::pack_or_pack_index(                    path,                    progress,                    verify::Context {                        output_statistics,                        thread_limit,                        algorithm,                        mode,                        out,                        err,                    },                )            },        )        .map(|_| ()),    }?;    Ok(())}