Fetch: compute the attestation signers once per operation head e10ba80000e1

    /// list per reference, computed once per operation head and kept

    /// (every bookmark move and tag is an operation): a client sends one

    /// fetch per bookmark, and on a bucket store each signature list is a

    /// LIST request, so recomputing per fetch cost metalgear2 (145

    /// bookmarks) 14 s a fetch.

        type Signers = std::collections::HashMap<(PathBuf, ObjectRef), BTreeSet<KeyId>>;

        static SERVED: std::sync::Mutex<Option<Signers>> = std::sync::Mutex::new(None);

        let key = (self.oxy.clone(), self.head_op()?.0);

        if let Some(keys) = SERVED

            .lock()

            .unwrap_or_else(|p| p.into_inner())

            .as_ref()

            .and_then(|m| m.get(&key))

        {

            return Ok(keys.clone());

        }

        let keys = self.attest_signers_now()?;

        let mut served = SERVED.lock().unwrap_or_else(|p| p.into_inner());

        let map = served.get_or_insert_with(Default::default);

        // One entry per repository: an older operation head is never asked

        // for again once a newer one is current.

        map.retain(|(oxy, _), _| *oxy != key.0);

        if map.len() >= 1024 {

            map.clear();

        }

        map.insert(key, keys.clone());

        Ok(keys)

    }

    fn attest_signers_now(&self) -> Result<BTreeSet<KeyId>> {