fetch + reset possible today?

[bittrance]

I'm trying to create a tool to maintain an up-to-date pristine checkout of a remote git repository. In traditional git cli terms, this entails git fetch origin plus git reset --hard origin/main. I understand that gitoxide does not yet implement merge and can therefore not yet implement pull properly, but my case does not depend on merging. However, there seems to be no fetch method that can operate on an existing repository?

I thought perhaps using receive() directly would allow implementing fetch locally, taking inspiration from repository/fetch.rs but that code seems only to implement part of a fetch workflow? Indeed, looking at the matching code from clone there are various private util methods invoked which seem to do relevant steps. Am I missing something obvious?

[Byron]

Worktree-resets are not implemented yet, but you can subscribe to this tracking ticket to receive updates. cargo needs this as well so it's going to be implemented as soon as possible.

[AravindPrabhs]

Hi, awesome work ! Think my git knowledge might letting me down here but would it be possible to effectively do git fetch && git checkout origin/main to achieve similar results with the current state of gitoxide ? I tried to get this done in a hacky way:

My reasoning was just repeat the fetch_and_checkout but without using prepare_clone since you get directory is not empty. Overall I thought it boiled down to fetching the remote (using remote....receive(), calling gix::clone::fetch::update_head, and then checking out the new head by calling prepare_checkout.main_worktree. In essence doing the special case of merge and just fast forward the head. However this didn't change my current state.

p.s. great project I've been developing a few Tauri apps on iOS recently, and had the idea to include git in some sort of management app and gitoxide slotted in perfectly, no extra linking shenanigans !

[AravindPrabhs]

Looking at the code for main_worktree I saw it called checkout with the index of the current head (which I thought update_head would move). But maybe as you said I need to clear the current working tree.

[AravindPrabhs]

Ok, thank you for your suggestion. Seems like update_head isn't doing what I expected, so followed the checkout route which was much better. The repo just ends up in a no diff state from origin/main but the work tree is still at the same commit as before - I don't mind this too much.

//  url & doc_path passed in.
...
       let repo = gix::open(&doc_path)?;
        // fetch remote HEAD of remote origin
        let remote_name = "origin";
        let remote = repo
            .remote_at(url.clone())?
            .with_refspecs(
                Some(format!("+refs/heads/*:refs/remotes/{remote_name}/*").as_str()),
                gix::remote::Direction::Fetch,
            )
            .expect("valid static spec");
        let head_refspec = gix_refspec::parse(
            format!("HEAD:refs/remotes/{remote_name}/HEAD")
                .as_str()
                .into(),
            gix_refspec::parse::Operation::Fetch,
        )
        .expect("valid")
        .to_owned();
        let res: gix::remote::fetch::Outcome = remote
            .connect(gix::remote::Direction::Fetch)?
            .prepare_fetch(&mut gix::progress::Discard, {
                let mut opts = gix::remote::ref_map::Options::default();
                if !opts.extra_refspecs.contains(&head_refspec) {
                    opts.extra_refspecs.push(head_refspec)
                }
                opts
            })?
            .with_write_packed_refs_only(true)
            .receive(&mut gix::progress::Discard, &gix::interrupt::IS_INTERRUPTED)?;

        // check if an extra pack has been received, and so a change on the remote.
        match res.status {
            gix::remote::fetch::Status::NoPackReceived {
                update_refs: _,
                negotiate: _,
                dry_run: _,
            } => {
                println!("No Changes!");
            }
            gix::remote::fetch::Status::Change {
                update_refs: _,
                write_pack_bundle: _,
                negotiate: _,
            } => {
                println!("Got Some Changes, checking out");
                // find the remote head's object id.
                let latest = res
                    .ref_map
                    .remote_refs
                    .iter()
                    .rev()
                    .filter_map(|x| match x {
                        gix::protocol::handshake::Ref::Direct {
                            full_ref_name,
                            object,
                        } => {
                            if full_ref_name == "refs/heads/main" {
                                Some(object.to_owned())
                            } else {
                                None
                            }
                        }
                        _ => None,
                    })
                    .next()
                    .unwrap();

                // get the tree for the object id in quesiton: just like in `main_worktree`
                let latest = repo
                    .find_object(latest)
                    .ok()
                    .and_then(|c| c.peel_to_tree().ok())
                    .unwrap()
                    .id;
                let index = gix_index::State::from_tree(&latest, |oid, buf| {
                    repo.objects.find_tree_iter(oid, buf).ok()
                })?;
                let mut index = gix_index::File::from_state(index, repo.index_path());

                // again same as in `main_worktree` to checkout the commit
                // mini helper to do repo.config.checkout_options(self, gix_worktree::stack::state::attributes::Source::IdMapping)
                let opts = repo.config_checkout_options()?;
                gix_worktree_state::checkout(
                    &mut index,
                    doc_path,
                    {
                        let objects = repo.objects.clone().into_arc()?;
                        move |oid, buf| objects.find_blob(oid, buf)
                    },
                    &mut Discard,
                    &mut Discard,
                    &gix::interrupt::IS_INTERRUPTED,
                    opts,
                )?;

                index.write(Default::default())?;
                println!("Repo checked out.",);
            }
        };
...

[AravindPrabhs]

This seems to work fine on my local machine, but running on iOS on some "pulls" I get quite a few artefacts in the files unsure if this is the web view not reloading the files properly will have to check (however it didn't go away with a restart of the app). Unfortunately the actually file directory isn't the easiest to debug.

edit: a fresh pull doesn't have these so something about the checkout is not liked.

[AravindPrabhs]

The issue seems to go away if I passed the following options instead of repo.config.checkout_options():

let opts = gix_worktree_state::checkout::Options {
    fs: Default::default(),
    thread_limit: Default::default(),
    destination_is_initially_empty: false,
    overwrite_existing: true,
    keep_going: false,
    stat_options: Default::default(),
    attributes: Default::default(),
    filters: Default::default(),
    filter_process_delay: Default::default(),
};

I assume the overwrite_existing being key. Overall I think that means my fork was entirely unnecessary and everything can be done with the current api.

I think that leaves me with a final question since I am unsure exactly how the index/checkout mechanism works. Will the checkout of the new commit from what is essentially a dirty working tree (but is in fact the last pulled commit from the remote), incur performance costs as the original commit gets further from remote head ? Or does the checkout walk the whole tree looking for things it needs to change ?

[Byron]

This checkout mechanism always checks out everything, writing every file. It's not reset(), and not git checkout - it's just a way to get an index checked out. Something akin to git checkout is planned.

[bittrance]

Indeed. My first draft similar to AravindPrabhs can be found at https://github.com/bittrance/kitops/blob/d39fda547985e53f2f8987c27bdef90fda8f28a0/src/git.rs . It simply checks out a new worktree into a temporary dir. It seems to work for simple cases.