let file_meta = InodeMetadata::new(0o644, false);

        let file_meta = InodeMetadata::new(0, false);

        let file_meta = InodeMetadata::new(0o755, true);

        let file_meta = InodeMetadata::new(0o100, true);

                        meta: InodeMetadata::new(0o755, true),

                        meta: InodeMetadata::new(0o100, true),

                    meta: InodeMetadata::new(0o755, true),

                    meta: InodeMetadata::new(0o100, true),

                *meta = InodeMetadata::new(permissions as usize, false);

                *meta = InodeMetadata::new(permissions as usize & 0o100, false);

                *meta = InodeMetadata::new(permissions as usize, true);

                *meta = InodeMetadata::new(permissions as usize & 0o100, true);

                        meta: InodeMetadata::new(0o644, false),

                        meta: InodeMetadata::new(0, false),

    debug!("repair_edges_context");

            debug!("to = {:?}", to);

                debug!("not alive");

                |h| changes.knows(&change_hash, &h).unwrap(),

        let mut it = txn.iter_graph(&channel.graph).unwrap();

        let mut it = txn.iter_graph(&channel.graph, None).unwrap();

        let mut it = txn.iter_graph(&channel.graph).unwrap();

        let mut it = txn.iter_graph(&channel.graph, None).unwrap();

        let mut it = txn.iter_graph(&channel.graph).unwrap();

        let mut it = txn.iter_graph(&channel.graph, None).unwrap();

                channel_changes.push(i)

                channel_changes.push(i.into())

    assert_eq!(bob_perm.0, 0o644);

    assert_eq!(bob_perm.0, 0);

    assert_eq!(bob_perm.0, 0o755);

    assert_eq!(bob_perm.0, 0o100);

    assert_eq!(alice_perm.0, 0o755);

    assert_eq!(alice_perm.0, 0o100);

use std::collections::{HashMap, HashSet};

pub(crate) fn repair_context_nondeleted<T: GraphMutTxnT, K>(

pub(crate) fn repair_context_nondeleted<T: GraphMutTxnT>(

    mut known: K,

) -> Result<(), MissingError<T::GraphError>>
where
    K: FnMut(Hash) -> bool,
{

) -> Result<(), MissingError<T::GraphError>> {

    if deleted_by_unknown(txn, channel, source, change_id, &mut known)? {
        debug!("deleted by unknown, repairing {:?}", source);
        repair_missing_up_context(txn, channel, ws, change_id, inode, source, &[target])?;
    }

    repair_missing_up_context(txn, channel, ws, change_id, inode, source, &[target])?;

}
fn deleted_by_unknown<T: GraphTxnT, K>(
    txn: &T,
    channel: &T::Graph,
    source: Vertex<ChangeId>,
    change_id: ChangeId,
    known: &mut K,
) -> Result<bool, TxnErr<T::GraphError>>
where
    K: FnMut(Hash) -> bool,
{
    let mut deleted_by_unknown = false;
    for v in iter_deleted_parents(txn, channel, source)? {
        let v = v?;
        if v.dest().change.is_root() || v.introduced_by().is_root() {
            continue;
        }
        if v.introduced_by() == change_id
            || known(txn.get_external(&v.introduced_by())?.unwrap().into())
        {
            // If a known change also delete the context, we're good.
            return Ok(false);
        } else {
            // If an unknown change deletes the context, wait: maybe a
            // known change will delete it too.
            deleted_by_unknown = true;
        }
    }
    Ok(deleted_by_unknown)

use crate::pristine::*;
use chrono::{DateTime, Utc};

            repair_context_nondeleted(
                txn,
                channel,
                &mut ws.missing_context,
                n.inode,
                change_id,
                |h| change.knows(&h),
                e,
            )
            .map_err(LocalApplyError::from_missing)?

            repair_context_nondeleted(txn, channel, &mut ws.missing_context, n.inode, change_id, e)
                .map_err(LocalApplyError::from_missing)?