dblsaiko/pijul - Change MQ6ERQ43MWASF2OSG65FHKWHCWT35BJVFJWKHAFPVCTLICCTJWUAC

Bug fixes when unrecording a patch that introduced zombie files

When unrecording a patch that introduced a zombie file by deleting a file, we must delete the paths made of pseudo-edges that represent the zombie conflict. The algorithm for finding that path was wrong, this patch replaces it with a proper one.

Created by pmeunier on October 27, 2023

MQ6ERQ43MWASF2OSG65FHKWHCWT35BJVFJWKHAFPVCTLICCTJWUAC

Dependencies

In channels

main

Change contents

Insertion in pijul/src/commands/debug.rs at line 7 [9.177758]
[8.31]
[9.177836]
```
use log::*;
```

Replacement in pijul/src/commands/debug.rs at line 44 [9.177758]

B:BD[10.21392] → [10.21392:21427]

B:BD[10.21427] → [7.0:74]

                let (pos, _) = txn
                    .follow_oldest_path(&repo.changes, &channel, &root)?;

[10.21392]

[10.21530]

                let pos = if let Some(pos) = parse_pos(&root) {
                    pos
                } else {
                    let inode = libpijul::fs::find_inode(&txn, &root)?;
                    debug!("inode {:?}", inode);
                    use libpijul::TreeTxnT;
                    if let Ok(Some(pos)) = txn.get_inodes(&inode, None) {
                        debug!("inode {:?}", pos);
                        *pos
                    } else {
                        debug!("no inode");
                        txn
                            .follow_oldest_path(&repo.changes, &channel, &root)?.0
                    }
                };

Insertion in pijul/src/commands/debug.rs at line 80 [9.177758]

[9.178663]

    }
}
fn parse_pos(s: &str) -> Option<libpijul::pristine::Position<libpijul::pristine::ChangeId>> {
    let mut it = s.split('.');
    if let (Some(a), Some(b)) = (it.next(),it.next()) {
        use libpijul::pristine::{Position, ChangeId, ChangePosition, Base32};
        let change = ChangeId::from_base32(a.as_bytes())?;
        let pos: u64 = b.parse().ok()?;
        Some(Position {
            change,
            pos: ChangePosition(pos.into()),
        })
    } else {
        None

Replacement in libpijul/src/unrecord/mod.rs at line 251 [9.231493]
B:BD[11.939] → [11.939:968]
```
        // edges are PSEUDO.
```
[11.939]
[11.968]
```
        // edges are PSEUDO|FOLDER.
```

Insertion in libpijul/src/unrecord/mod.rs at line 259 [9.231493]

[6.123]

                        debug!("line {}, del {:?} {:?} {:?}", line!(), u, v, e);

Insertion in libpijul/src/unrecord/mod.rs at line 264 [9.231493]

[6.312]

                        debug!("line {}, del {:?} {:?} {:?}", line!(), v, w, e);

Insertion in libpijul/src/unrecord/mod.rs at line 293 [9.231493]
[12.69]
[9.235977]
```
    zombies_stack: Vec<(Vertex<ChangeId>, bool, bool)>,
```

Insertion in libpijul/src/unrecord/mod.rs at line 353 [9.231493]

[9.238407]

[13.8010]

            debug!("line {}, del {:?} {:?} {:?}", line!(), a, b, e);

Insertion in libpijul/src/unrecord/mod.rs at line 591 [9.231493]

[14.18573]

                debug!("line {}, del {:?} {:?} {:?}", line!(), u, v, e);

Insertion in libpijul/src/unrecord/mod.rs at line 595 [9.231493]

[14.18721]

                debug!("line {}, del {:?} {:?} {:?}", line!(), v, w, e);

Replacement in libpijul/src/unrecord/mod.rs at line 614 [9.231493]
B:BD[15.3151] → [15.3151:3198]
```
        debug!("remove_zombies, v = {:?}", v);
```
[15.3151]
[15.3198]
```
        debug!("collect_zombies, v = {:?}", v);
```
Insertion in libpijul/src/unrecord/mod.rs at line 652 [9.231493]
[11.2201]
[6.430]
```
    // First, collect the paths downwards.
```

Replacement in libpijul/src/unrecord/mod.rs at line 655 [9.231493]

B:BD[6.480] → [6.480:508]

        ws.stack.push(*to);

[6.480]

[6.508]

        ws.zombies_stack.push((*to, false, false))
    }
    while let Some((v, alive, on_path)) = ws.zombies_stack.pop() {
        if on_path {
            // Already visited. If not alive, delete PSEUDO edges.
            if !alive {
                for e in iter_adj_all(txn, channel, v)? {
                    let e = e?;
                    if e.flag().contains(EdgeFlags::PSEUDO) {
                        ws.del_edges.push((v, *e))
                    }
                }
                if ws.zombies_stack.is_empty() {
                    debug_assert_eq!(v.start_pos(), to);
                    // Collect all the pseudo-paths up.
                    ws.parents.clear();
                    collect_zombies_up(txn, channel, to, ws)?
                }
            }
            continue
        }
        // A vertex cannot be marked alive if it wasn't on the path.
        assert!(!alive);
        // If the vertex was already visited in another path, pass.
        if !ws.parents.insert(v) {
            continue;
        }
        // Else, iterate through all children. If any of them is
        // alive, mark the entire path as alive. Else, just push onto
        // the stack and continue the DFS.
        let mut is_first = true;
        for e in iter_alive_children(txn, channel, v)? {
            let e = e?;
            if e.flag().intersects(EdgeFlags::PARENT | EdgeFlags::DELETED) {
                continue
            }
            let x = txn.find_block(channel, e.dest())?;
            if is_alive(txn, channel, x)? {
                // Mark all edges on the path as alive.
                for (_, alive, on_path) in ws.zombies_stack.iter_mut() {
                    if *on_path {
                        *alive = true
                    }
                }
            } else {
                if is_first {
                    is_first = false;
                    ws.zombies_stack.push((v, false, true))
                }
                ws.zombies_stack.push((*x, false, false))
            }
        }
    }
    ws.zombies_stack.clear();
    ws.parents.clear();
    Ok(())
}
fn collect_zombies_up<T: GraphTxnT>(
    txn: &T,
    channel: &T::Graph,
    to: Position<ChangeId>,
    ws: &mut Workspace,
) -> Result<(), BlockError<T::GraphError>> {
    if let Ok(&to) = txn.find_block(channel, to) {
        ws.stack.push(to);

Insertion in libpijul/src/unrecord/mod.rs at line 727 [9.231493]
[6.514]
[11.2251]

Deletion in libpijul/src/unrecord/mod.rs at line 738 [9.231493]

B:BD[11.2597] → [11.2597:2869]

            if (e.flag() & (EdgeFlags::PSEUDO | EdgeFlags::DELETED)).is_empty() {
                // This isn't a pseudo edge, `v` isn't part
                ws.del_edges.truncate(del_len);
                ws.stack.truncate(stack_len);
                break
            }

Insertion in libpijul/src/unrecord/mod.rs at line 739 [9.231493]

[11.2923]

[6.515]


                assert!(e.flag().contains(EdgeFlags::FOLDER));
                if !e.flag().intersects(EdgeFlags::PSEUDO | EdgeFlags::DELETED) {
                    // Neither a pseudo edge nor a deleted edge.
                    ws.del_edges.truncate(del_len);
                    ws.stack.truncate(stack_len);
                    break
                }

Replacement in libpijul/src/unrecord/mod.rs at line 751 [9.231493]

∅:D[6.642] → [11.2994:3015]

B:BD[11.2994] → [11.2994:3015]

B:BD[11.3015] → [6.643:748]

            } else {
                if let Ok(x) = txn.find_block(channel, e.dest()) {
                    ws.stack.push(*x)

[6.642]

[6.748]

                if e.flag().contains(EdgeFlags::PSEUDO) {
                    ws.del_edges.push((v, *e))

Deletion in libpijul/src/unrecord/mod.rs at line 755 [9.231493]
B:BD[11.3096] → [11.3096:3150]
∅:D[11.3150] → [14.19204:19247]
B:BD[14.19204] → [14.19204:19247]
∅:D[14.19247] → [15.3796:3810]
B:BD[15.3796] → [15.3796:3810]
```
            if e.flag().contains(EdgeFlags::PSEUDO) {
                ws.del_edges.push((v, *e))
            }
```

Replacement in libpijul/src/record.rs at line 1220 [9.488880]

B:BD[4.3954] → [4.3954:4017]

                retrieve(&*txn, txn.graph(&*channel), vertex)?

[4.3954]

[4.4017]

                retrieve(&*txn, txn.graph(&*channel), vertex, false)?

Replacement in libpijul/src/pristine/mod.rs at line 1339 [9.586748]

B:BD[16.67436] → [14.106045:106106]

            if e.flag().contains(EdgeFlags::PARENT) ^ down {

[16.67436]

[14.106106]

            if e.flag().contains(EdgeFlags::PARENT) != down {

Replacement in libpijul/src/pristine/mod.rs at line 2211 [9.586748]

B:BD[17.835] → [18.3822:3917]

        let graph = crate::alive::retrieve::retrieve(txn, txn.graph(channel), file_).unwrap();

[17.835]

[18.3917]

        let graph = crate::alive::retrieve::retrieve(txn, txn.graph(channel), file_, true).unwrap();

Replacement in libpijul/src/pristine/mod.rs at line 2215 [9.586748]

B:BD[17.906] → [18.3996:4072]

        debug_root(txn, txn.graph(channel), file.unwrap(), &mut f, false)?;

[17.906]

[19.3117]

        debug_root(txn, txn.graph(channel), file.unwrap(), &mut f, true)?;

Replacement in libpijul/src/output/output.rs at line 770 [9.671807]

B:BD[20.86] → [20.86:150]

        retrieve(&*txn, txn.graph(&*channel), output_item.pos)?

[20.86]

[20.150]

        retrieve(&*txn, txn.graph(&*channel), output_item.pos, false)?

Insertion in libpijul/src/output/mod.rs at line 258 [9.686190]

[21.23999]

        return Ok(());
        // The following was supposed to be a panic, but actually it
        // doesn't need to be one, there just wasn't any file to
        // output.
        /*

Insertion in libpijul/src/output/mod.rs at line 281 [9.686190]
[21.24566]
[21.24566]
```
        */
```

Replacement in libpijul/src/output/mod.rs at line 339 [9.686190]

B:BD[4.4295] → [4.4295:4360]

        crate::alive::retrieve(&*txn, txn.graph(&*channel), v0)?

[4.4295]

[4.4360]

        crate::alive::retrieve(&*txn, txn.graph(&*channel), v0, false)?

Replacement in libpijul/src/output/archive.rs at line 268 [9.690044]

B:BD[4.5681] → [4.5681:5778]

                        crate::alive::retrieve(&*txn_, txn_.graph(&channel_), output_item.pos)?;

[4.5681]

[22.0]

                        crate::alive::retrieve(&*txn_, txn_.graph(&channel_), output_item.pos, false)?;

Replacement in libpijul/src/missing_context.rs at line 46 [9.696460]

B:BD[9.697496] → [16.88998:89078]

                    let mut graph = crate::alive::retrieve(txn, channel, pos)?;

[9.697496]

[9.697575]

                    let mut graph = crate::alive::retrieve(txn, channel, pos, false)?;

Insertion in libpijul/src/missing_context.rs at line 367 [9.696460]

[2.3800]

        debug!("detect folder conflict resolution, deleting {:?} → {:?} {:?}", v, e, p);

Insertion in libpijul/src/find_alive.rs at line 166 [9.763306]

[23.734]

[14.135056]

            if v.flag() & EdgeFlags::pseudof() == EdgeFlags::PSEUDO {
                continue;
            }

Insertion in libpijul/src/find_alive.rs at line 170 [9.763306]

[14.135095]

                debug!("is_file {:?} {:?}", is_file, !v.flag().is_folder());

Deletion in libpijul/src/find_alive.rs at line 172 [9.763306]
∅:D[15.15924] → [9.766374:766414]
∅:D[14.135145] → [9.766374:766414]
B:BD[9.766374] → [9.766374:766414]
B:BD[9.766414] → [14.135146:135216]
```
                continue;
            }
            if v.flag() & EdgeFlags::pseudof() == EdgeFlags::PSEUDO {
```

Replacement in libpijul/src/find_alive.rs at line 175 [9.763306]

B:BD[14.135257] → [3.6236:6275]

                if vertex == vertex0 {

[14.135257]

[3.6275]

                if v.flag().is_block() && vertex == vertex0 {

Insertion in libpijul/src/find_alive.rs at line 212 [9.763306]

[14.135477]

[3.7231]

                for e in it {
                    let e = e?;
                    is_file |= !e.flag().intersects(EdgeFlags::parent_folder())
                }
                debug!("{:?} is a file ? {:?}", vertex, is_file);

Replacement in libpijul/src/apply.rs at line 337 [9.944089]

B:BD[9.949433] → [5.1565:1845]

                Atom::NewVertex(ref n) => put_newvertex(
                    txn,
                    T::graph_mut(channel),
                    changes,
                    change,
                    ws,
                    change_id,
                    n,
                )?,

[9.949433]

[9.949531]

                Atom::NewVertex(ref n) => {
                    put_newvertex(
                        txn,
                        T::graph_mut(channel),
                        changes,
                        change,
                        ws,
                        change_id,
                        n,
                    )?
                },

Insertion in libpijul/src/apply.rs at line 384 [9.944089]

[9.951555]


                    {
                        let file = Vertex {
                            change: ChangeId(L64(5867590239053715538)),
                            start: ChangePosition(204370u64.into()),
                            end: ChangePosition(204370u64.into()),
                        };
                        let still_here: Vec<_> = iter_adjacent(
                            txn,
                            T::graph_mut(channel),
                            file,
                            EdgeFlags::empty(),
                            EdgeFlags::all(),
                        )?.collect();
                        debug!("still here! {:?}", still_here);
                    }

Insertion in libpijul/src/apply.rs at line 586 [9.944089]

[9.971508]

[14.146962]

        debug!("clean_obsolete_pseudo_edges {:?} {:?} {:?}", next_vertex, p, inode);
        {
            let still_here: Vec<_> = iter_adjacent(
                txn,
                channel,
                next_vertex,
                EdgeFlags::empty(),
                EdgeFlags::all(),
            )?.collect();
            debug!("pseudo edge still here ? {:?} {:?}", next_vertex.change.0.0, still_here)
        }

Insertion in libpijul/src/apply/edge.rs at line 270 [10.96160]

[24.44053]

[10.103957]

    debug!("reconnect pseudo edges, parents = {:?}", ws.parents);
    debug!("reconnect pseudo edges, children = {:?}", ws.children);

Insertion in libpijul/src/alive/retrieve.rs at line 10 [9.984582]
[16.134379]
[16.134379]
```
    include_deleted: bool,
```

Replacement in libpijul/src/alive/retrieve.rs at line 42 [9.984582]

B:BD[9.985908] → [9.985908:985958]

            EdgeFlags::PSEUDO | EdgeFlags::BLOCK,

[9.985908]

[16.134424]

            if include_deleted {
                EdgeFlags::PSEUDO | EdgeFlags::BLOCK | EdgeFlags::DELETED
            } else {
                EdgeFlags::PSEUDO | EdgeFlags::BLOCK
            },

Insertion in libpijul/src/alive/retrieve.rs at line 49 [9.984582]

[16.134461]

[14.148298]

            if e.flag().intersects(EdgeFlags::PARENT) {
                continue
            }

Replacement in libpijul/src/alive/retrieve.rs at line 123 [9.984582]
B:BD[16.135400] → [16.135400:135450]
```
    let mut graph = retrieve(txn, channel, pos)?;
```
[16.135400]
[9.987863]
```
    let mut graph = retrieve(txn, channel, pos, false)?;
```