jcdickinson/pijul - Change 5MRZLKBHOFFUAJELWL34XILG2XVWPUEHOFPDXBK5ASCO6H26MBFAC

Changing the type of the tags db, to make it identical to remote tags

Created by pmeunier on December 20, 2021

5MRZLKBHOFFUAJELWL34XILG2XVWPUEHOFPDXBK5ASCO6H26MBFAC

Dependencies

In channels

main

Change contents

Replacement in pijul/src/commands/tag.rs at line 114 [6.74]

B:BD[6.3358] → [2.302:379]

                txn.write().put_tags(&mut *channel.write(), last_t.into())?;

[6.3358]

[6.3432]

                txn.write()
                    .put_tags(&mut channel.write().tags, last_t.into(), &h)?;

Insertion in pijul/src/commands/pushpull.rs at line 394 [8.111631]
[7.21985]
[7.21985]
```
            tags,
```

Replacement in pijul/src/commands/protocol.rs at line 182 [8.123281]

B:BD[3.1732] → [3.1732:1817]

                        txn.write().put_tags(&mut *channel.write(), last_t.into())?;

[3.1732]

[3.1817]

                        txn.write()
                            .put_tags(&mut channel.write().tags, last_t.into(), &m)?;

Replacement in libpijul/src/tag.rs at line 227 [6.6397]

B:BD[6.12064] → [2.1907:1953]

        |_, _, k: &L64, v: &()| Ok((*k, *v)),

[6.12064]

[6.12122]

        |_, _, k: &L64, v: &Pair<SerializedMerkle, SerializedMerkle>| Ok((*k, *v)),

Replacement in libpijul/src/pristine/sanakirja.rs at line 340 [8.531056]

B:BD[9.25881] → [9.25881:25963]

            let tags: UDb<L64, SerializedHash> = UDb::from_page(tup.tags.into());

[9.25881]

[10.62979]

            let tags: UDb<L64, Pair<SerializedMerkle, SerializedMerkle>> =
                UDb::from_page(tup.tags.into());

Replacement in libpijul/src/pristine/sanakirja.rs at line 727 [8.531056]
B:BD[10.70500] → [2.3859:3886]
```
    pub tags: Db<L64, ()>,
```
[10.70500]
[11.39127]
```
    pub tags: Db<L64, Pair<SerializedMerkle, SerializedMerkle>>,
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 927 [8.531056]
B:BD[6.23105] → [2.3887:3916]
```
    type Tags = Db<L64, ()>;
```
[6.23105]
[2.3916]
```
    type Tags = Db<L64, Pair<SerializedMerkle, SerializedMerkle>>;
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 933 [8.531056]
B:BD[2.4139] → [2.4139:4166]
```
            _ => Ok(false)
```
[2.4139]
[6.23430]
```
            _ => Ok(false),
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 937 [8.531056]

B:BD[6.23447] → [6.23447:23469]

B:BD[6.23469] → [2.4167:4232]

    type TagsCursor =
        ::sanakirja::btree::cursor::Cursor<L64, (), P<L64, ()>>;

[6.23447]

[6.23559]

    type TagsCursor = ::sanakirja::btree::cursor::Cursor<
        L64,
        Pair<SerializedMerkle, SerializedMerkle>,
        P<L64, Pair<SerializedMerkle, SerializedMerkle>>,
    >;

Replacement in libpijul/src/pristine/sanakirja.rs at line 988 [8.531056]

B:BD[12.2167] → [12.2167:2184]

B:BD[12.2184] → [2.4500:4563]

∅:D[2.4563] → [12.2259:2301]

B:BD[12.2259] → [12.2259:2301]

    ) -> Result<
        super::Cursor<Self, &Self, Self::TagsCursor, L64, ()>,
        TxnErr<Self::GraphError>,
    > {

[12.2167]

[12.2301]

    ) -> Result<super::Cursor<Self, &Self, Self::TagsCursor, L64, ()>, TxnErr<Self::GraphError>>
    {

Replacement in libpijul/src/pristine/sanakirja.rs at line 997 [8.531056]

B:BD[12.2455] → [12.2455:2472]

B:BD[12.2472] → [2.4564:4630]

∅:D[2.4630] → [12.2550:2592]

B:BD[12.2550] → [12.2550:2592]

    ) -> Result<
        super::RevCursor<Self, &Self, Self::TagsCursor, L64, ()>,
        TxnErr<Self::GraphError>,
    > {

[12.2455]

[12.2592]

    ) -> Result<super::RevCursor<Self, &Self, Self::TagsCursor, L64, ()>, TxnErr<Self::GraphError>>
    {

Insertion in libpijul/src/pristine/sanakirja.rs at line 1382 [8.531056]
[10.79838]
[10.79838]
```
    type Remotetags = UDb<L64, Pair<SerializedMerkle, SerializedMerkle>>;
```

Insertion in libpijul/src/pristine/sanakirja.rs at line 1391 [8.531056]

[8.554746]

    sanakirja_cursor!(remotetags, L64, Pair<SerializedMerkle, SerializedMerkle>);
    sanakirja_rev_cursor!(remotetags, L64, Pair<SerializedMerkle, SerializedMerkle>);
    type RemotetagsCursor = ::sanakirja::btree::cursor::Cursor<
        L64,
        Pair<SerializedMerkle, SerializedMerkle>,
        UP<L64, Pair<SerializedMerkle, SerializedMerkle>>,
    >;

Insertion in libpijul/src/pristine/sanakirja.rs at line 1474 [8.531056]

[8.556376]

[13.48966]

    fn last_remote_tag(
        &self,
        remote: &Self::Remotetags,
    ) -> Result<Option<(u64, &SerializedMerkle, &SerializedMerkle)>, TxnErr<Self::GraphError>> {
        if let Some(x) = btree::rev_iter(&self.txn, remote, None)?.next() {
            let (&k, v) = x?;
            Ok(Some((k.into(), &v.a, &v.b)))
        } else {
            Ok(None)
        }
    }

Replacement in libpijul/src/pristine/sanakirja.rs at line 1674 [8.531056]

B:BD[10.83995] → [10.83995:84030]

                (&(x?.1).b).into()

[10.83995]

[8.560596]

                let (a, b) = x?;
                let a: u64 = (*a).into();
                assert!(a < t);
                (&b.b).into()

Replacement in libpijul/src/pristine/sanakirja.rs at line 1734 [8.531056]

B:BD[10.85003] → [10.85003:85071]

                m = m.next(&self.get_external(p)?.unwrap().into());

[10.85003]

[10.85071]

                m = m.next(self.get_external(p)?.unwrap());

Replacement in libpijul/src/pristine/sanakirja.rs at line 1755 [8.531056]

B:BD[6.25236] → [6.25236:25300]

        channel: &mut Self::Channel,
        t: ApplyTimestamp,

[6.25236]

[6.25318]

        channel: &mut Self::Tags,
        n: u64,
        m: &Merkle,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1759 [8.531056]

B:BD[6.25366] → [2.4690:4761]

∅:D[2.4761] → [6.25443:25458]

B:BD[6.25443] → [6.25443:25458]

        btree::put(&mut self.txn, &mut channel.tags, &t.into(), &())?;
        Ok(())

[6.25366]

[6.25458]

        debug!("put_tags {:?}", m);
        let mm: SerializedMerkle = m.into();
        if btree::get(&self.txn, &channel, &n.into(), None)?.is_some() {
            debug!("already tagged");
            Ok(())
        } else {
            let tl = n.into();
            let mut repl = vec![(tl, mm)];
            replay_tags(self, channel, tl, &mut repl)?;
            Ok(())
        }

Replacement in libpijul/src/pristine/sanakirja.rs at line 1774 [8.531056]

B:BD[6.25501] → [6.25501:25565]

        channel: &mut Self::Channel,
        t: ApplyTimestamp,

[6.25501]

[6.25565]

        channel: &mut Self::Tags,
        t: u64,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1777 [8.531056]

B:BD[6.25613] → [6.25613:25685]

        btree::del(&mut self.txn, &mut channel.tags, &t.into(), None)?;

[6.25613]

[6.25685]

        replay_tags(self, channel, t.into(), &mut Vec::new())?;

Insertion in libpijul/src/pristine/sanakirja.rs at line 1782 [8.531056]

[13.50939]

fn replay_tags(
    txn: &mut MutTxn<()>,
    channel: &mut Db<L64, Pair<SerializedMerkle, SerializedMerkle>>,
    tl: L64,
    repl: &mut Vec<(L64, SerializedMerkle)>,
) -> Result<(), TxnErr<SanakirjaError>> {
    let del = repl.is_empty();
    for x in btree::iter(&txn.txn, &channel, Some((&tl, None)))? {
        let (t_, p) = x?;
        if *t_ >= tl {
            repl.push((*t_, p.a))
        }
    }
    let mut m = Merkle::zero();
    for x in btree::rev_iter(&txn.txn, &channel, Some((&tl, None)))? {
        let (t_, mm) = x?;
        if t_ < &tl {
            m = (&mm.b).into();
            break;
        }
    }
    for (t_, p) in repl.iter() {
        debug!("del_changes {:?} {:?}", t_, p);
        btree::del(&mut txn.txn, channel, t_, None)?;
        if *t_ > tl || !del {
            m = m.next(p);
            btree::put(&mut txn.txn, channel, t_, &Pair { a: *p, b: m.into() })?;
        }
    }
    Ok(())
}

Replacement in libpijul/src/pristine/sanakirja.rs at line 1853 [8.531056]
∅:D[5.3643] → [13.52484:52526]
B:BD[8.562319] → [13.52484:52526]
```
    ) -> Result<bool, Self::GraphError> {
```
[5.3643]
[14.99033]
```
    ) -> Result<bool, TxnErr<Self::GraphError>> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1865 [8.531056]

B:BD[5.3661] → [5.3661:3735]

            btree::put(&mut self.txn, &mut remote.tags, &k.into(), &())?;

[5.3661]

[5.3735]

            self.put_tags(&mut remote.tags, k, &v.1)?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 1874 [8.531056]
B:BD[13.52619] → [13.52619:52661]
```
    ) -> Result<bool, Self::GraphError> {
```
[13.52619]
[14.99077]
```
    ) -> Result<bool, TxnErr<Self::GraphError>> {
```
Insertion in libpijul/src/pristine/mod.rs at line 677 [8.586748]
[8.605760]
[8.605760]
```
    table!(remotetags);
```

Insertion in libpijul/src/pristine/mod.rs at line 682 [8.586748]

[10.103300]

[8.605897]

    cursor!(remotetags, L64, Pair<SerializedMerkle, SerializedMerkle>);
    rev_cursor!(remotetags, L64, Pair<SerializedMerkle, SerializedMerkle>);

Insertion in libpijul/src/pristine/mod.rs at line 719 [8.586748]

[15.36994]

[13.59531]

    fn last_remote_tag(
        &self,
        remote: &Self::Remotetags,
    ) -> Result<Option<(u64, &SerializedMerkle, &SerializedMerkle)>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 1797 [8.586748]

B:BD[6.27347] → [6.27347:27411]

        channel: &mut Self::Channel,
        t: ApplyTimestamp,

[6.27347]

[6.27429]

        channel: &mut Self::Tags,
        n: u64,
        m: &Merkle,

Replacement in libpijul/src/pristine/mod.rs at line 1804 [8.586748]

B:BD[6.27513] → [6.27513:27577]

        channel: &mut Self::Channel,
        t: ApplyTimestamp,

[6.27513]

[6.27577]

        channel: &mut Self::Tags,
        n: u64,

Replacement in libpijul/src/pristine/mod.rs at line 1882 [8.586748]
∅:D[5.3962] → [13.74624:74665]
B:BD[8.638359] → [13.74624:74665]
```
    ) -> Result<bool, Self::GraphError>;
```
[5.3962]
[8.638397]
```
    ) -> Result<bool, TxnErr<Self::GraphError>>;
```
Replacement in libpijul/src/pristine/mod.rs at line 1888 [8.586748]
B:BD[13.74758] → [13.74758:74799]
```
    ) -> Result<bool, Self::GraphError>;
```
[13.74758]
[8.638497]
```
    ) -> Result<bool, TxnErr<Self::GraphError>>;
```

Insertion in libpijul/src/pristine/merkle.rs at line 33 [8.638683]

[4.195]

        }
    }
}
impl From<&super::Hash> for curve25519_dalek::scalar::Scalar {
    fn from(h: &super::Hash) -> Self {
        match h {
            super::Hash::Blake3(h) => {
                curve25519_dalek::scalar::Scalar::from_bytes_mod_order(*h)
            }
            _ => unreachable!(),

Insertion in libpijul/src/pristine/merkle.rs at line 48 [8.638683]

[8.639295]

impl From<&super::SerializedHash> for curve25519_dalek::scalar::Scalar {
    fn from(h: &super::SerializedHash) -> Self {
        let h: super::Hash = h.into();
        (&h).into()
    }
}
impl From<&Merkle> for curve25519_dalek::scalar::Scalar {
    fn from(h: &Merkle) -> Self {
        match *h {
            Merkle::Ed25519(h) => {
                let h = h.compress();
                curve25519_dalek::scalar::Scalar::from_bytes_mod_order(*h.as_bytes())
            }
        }
    }
}
impl From<&super::SerializedMerkle> for curve25519_dalek::scalar::Scalar {
    fn from(h: &super::SerializedMerkle) -> Self {
        let h: Merkle = h.into();
        (&h).into()
    }
}

Replacement in libpijul/src/pristine/merkle.rs at line 77 [8.638683]

B:BD[8.639392] → [8.639392:639442]

    pub fn next(&self, h: &super::Hash) -> Self {

[8.639392]

[8.639442]

    pub fn next<S: Into<curve25519_dalek::scalar::Scalar>>(&self, h: S) -> Self {

Replacement in libpijul/src/pristine/merkle.rs at line 80 [8.638683]

B:BD[8.639504] → [8.639504:639756]

                let scalar = match *h {
                    super::Hash::Blake3(h) => {
                        curve25519_dalek::scalar::Scalar::from_bytes_mod_order(h)
                    }
                    _ => unreachable!(),
                };

[8.639504]

[8.639756]

                let scalar = h.into();