InferredCopyFrom: add InferredCopyFrom types

Summary: As title

Reviewed By: markbt

Differential Revision: D75144171

fbshipit-source-id: 66a66c00fb878415b3d8e8ea99f10356e82262c2

Author: Liu Yang

eden/mononoke/mononoke_types/src/blob.rs

@@ -27,6 +27,7 @@ use crate::typed_hash::DeletedManifestV2Id;
 use crate::typed_hash::FastlogBatchId;
 use crate::typed_hash::FileUnodeId;
 use crate::typed_hash::FsnodeId;
+use crate::typed_hash::InferredCopyFromId;
 use crate::typed_hash::ManifestUnodeId;
 use crate::typed_hash::RawBundle2Id;
 use crate::typed_hash::RedactionKeyListId;
@@ -100,6 +101,7 @@ pub type TestManifestBlob = Blob<TestManifestId>;
 pub type TestShardedManifestBlob = Blob<TestShardedManifestId>;
 pub type SkeletonManifestV2Blob = Blob<SkeletonManifestV2Id>;
 pub type CaseConflictSkeletonManifestBlob = Blob<CaseConflictSkeletonManifestId>;
+pub type InferredCopyFromBlob = Blob<InferredCopyFromId>;
 
 impl<Id: BlobstoreKey> From<Blob<Id>> for BlobstoreBytes {
     #[inline]

eden/mononoke/mononoke_types/src/inferred_copy_from.rs

@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This software may be used and distributed according to the terms of the
+ * GNU General Public License version 2.
+ */
+
+use anyhow::Result;
+use blobstore::Blobstore;
+use context::CoreContext;
+use futures::stream::BoxStream;
+use futures::stream::StreamExt;
+use futures::stream::TryStreamExt;
+
+use crate::Blob;
+use crate::BlobstoreValue;
+use crate::ThriftConvert;
+use crate::blob::InferredCopyFromBlob;
+use crate::path::MPath;
+use crate::sharded_map_v2::ShardedMapV2Node;
+use crate::sharded_map_v2::ShardedMapV2Value;
+use crate::thrift;
+use crate::typed_hash::ChangesetId;
+use crate::typed_hash::IdContext;
+use crate::typed_hash::InferredCopyFromContext;
+use crate::typed_hash::InferredCopyFromId;
+use crate::typed_hash::ShardedMapV2NodeInferredCopyFromContext;
+use crate::typed_hash::ShardedMapV2NodeInferredCopyFromId;
+
+#[derive(ThriftConvert, Debug, Clone, PartialEq, Eq, Hash)]
+#[thrift(thrift::inferred_copy_from::InferredCopyFrom)]
+pub struct InferredCopyFrom {
+    pub subentries: ShardedMapV2Node<InferredCopyFromEntry>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct InferredCopyFromEntry {
+    pub from_csid: ChangesetId,
+    pub from_path: MPath,
+}
+
+impl ThriftConvert for InferredCopyFromEntry {
+    const NAME: &'static str = "InferredCopyFromEntry";
+    type Thrift = thrift::inferred_copy_from::InferredCopyFromEntry;
+
+    fn from_thrift(t: Self::Thrift) -> Result<Self> {
+        Ok(Self {
+            from_csid: ChangesetId::from_thrift(t.from_csid)?,
+            from_path: MPath::from_thrift(t.from_path)?,
+        })
+    }
+
+    fn into_thrift(self) -> Self::Thrift {
+        Self::Thrift {
+            from_csid: self.from_csid.into_thrift(),
+            from_path: self.from_path.into_thrift(),
+        }
+    }
+}
+
+impl ShardedMapV2Value for InferredCopyFromEntry {
+    type NodeId = ShardedMapV2NodeInferredCopyFromId;
+    type Context = ShardedMapV2NodeInferredCopyFromContext;
+    type RollupData = ();
+
+    const WEIGHT_LIMIT: usize = 2000;
+}
+
+impl InferredCopyFrom {
+    pub fn empty() -> Self {
+        Self {
+            subentries: ShardedMapV2Node::default(),
+        }
+    }
+
+    pub async fn lookup(
+        &self,
+        ctx: &CoreContext,
+        blobstore: &impl Blobstore,
+        path: &MPath,
+    ) -> Result<Option<InferredCopyFromEntry>> {
+        self.subentries
+            .lookup(ctx, blobstore, &path.to_null_separated_bytes())
+            .await
+    }
+
+    pub async fn from_subentries(
+        ctx: &CoreContext,
+        blobstore: &impl Blobstore,
+        subentries: impl IntoIterator<Item = (MPath, InferredCopyFromEntry)>,
+    ) -> Result<Self> {
+        Ok(Self {
+            subentries: ShardedMapV2Node::from_entries(
+                ctx,
+                blobstore,
+                subentries
+                    .into_iter()
+                    .map(|(path, entry)| (path.to_null_separated_bytes(), entry)),
+            )
+            .await?,
+        })
+    }
+
+    pub fn into_subentries<'a>(
+        self,
+        ctx: &'a CoreContext,
+        blobstore: &'a impl Blobstore,
+    ) -> BoxStream<'a, Result<(MPath, InferredCopyFromEntry)>> {
+        self.subentries
+            .into_entries(ctx, blobstore)
+            .and_then(
+                |(k, v)| async move { Ok((MPath::from_null_separated_bytes(k.to_vec())?, v)) },
+            )
+            .boxed()
+    }
+
+    pub fn into_prefix_subentries<'a>(
+        self,
+        ctx: &'a CoreContext,
+        blobstore: &'a impl Blobstore,
+        prefix: &'a [u8],
+    ) -> BoxStream<'a, Result<(MPath, InferredCopyFromEntry)>> {
+        self.subentries
+            .into_prefix_entries(ctx, blobstore, prefix)
+            .map(|res| {
+                res.and_then(|(k, v)| Ok((MPath::from_null_separated_bytes(k.to_vec())?, v)))
+            })
+            .boxed()
+    }
+}
+
+impl BlobstoreValue for InferredCopyFrom {
+    type Key = InferredCopyFromId;
+
+    fn into_blob(self) -> InferredCopyFromBlob {
+        let data = self.into_bytes();
+        let id = InferredCopyFromContext::id_from_data(&data);
+        Blob::new(id, data)
+    }
+
+    fn from_blob(blob: Blob<Self::Key>) -> Result<Self> {
+        Self::from_bytes(blob.data())
+    }
+}

eden/mononoke/mononoke_types/src/lib.rs

@@ -29,6 +29,7 @@ pub mod fsnode;
 pub mod generation;
 pub mod globalrev;
 pub mod hash;
+pub mod inferred_copy_from;
 pub mod path;
 pub mod prefix_tree;
 pub mod rawbundle2;
@@ -119,6 +120,7 @@ pub use typed_hash::DeletedManifestV2Id;
 pub use typed_hash::FastlogBatchId;
 pub use typed_hash::FileUnodeId;
 pub use typed_hash::FsnodeId;
+pub use typed_hash::InferredCopyFromId;
 pub use typed_hash::ManifestUnodeId;
 pub use typed_hash::MononokeId;
 pub use typed_hash::RawBundle2Id;
@@ -143,6 +145,7 @@ pub mod thrift {
     pub use mononoke_types_serialization::fastlog;
     pub use mononoke_types_serialization::fsnodes;
     pub use mononoke_types_serialization::id;
+    pub use mononoke_types_serialization::inferred_copy_from;
     pub use mononoke_types_serialization::path;
     pub use mononoke_types_serialization::raw_bundle2;
     pub use mononoke_types_serialization::redaction;

eden/mononoke/mononoke_types/src/typed_hash.rs

@@ -44,6 +44,8 @@ use crate::file_contents::FileContents;
 use crate::fsnode::Fsnode;
 use crate::hash::Blake2;
 use crate::hash::Blake2Prefix;
+use crate::inferred_copy_from::InferredCopyFrom;
+use crate::inferred_copy_from::InferredCopyFromEntry;
 use crate::rawbundle2::RawBundle2;
 use crate::redaction_key_list::RedactionKeyList;
 use crate::sharded_map::ShardedMapNode;
@@ -214,6 +216,12 @@ pub struct FastlogBatchId(Blake2);
 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
 pub struct RedactionKeyListId(Blake2);
 
+#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
+pub struct InferredCopyFromId(Blake2);
+
+#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
+pub struct ShardedMapV2NodeInferredCopyFromId(Blake2);
+
 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
 pub struct TestManifestId(Blake2);
 
@@ -734,6 +742,22 @@ impl_typed_hash! {
     context_key => "fastlogbatch",
 }
 
+impl_typed_hash! {
+    hash_type => InferredCopyFromId,
+    thrift_hash_type => thrift::id::InferredCopyFromId,
+    value_type => InferredCopyFrom,
+    context_type => InferredCopyFromContext,
+    context_key => "icf",
+}
+
+impl_typed_hash! {
+    hash_type => ShardedMapV2NodeInferredCopyFromId,
+    thrift_hash_type => thrift::id::ShardedMapV2NodeId,
+    value_type => ShardedMapV2Node<InferredCopyFromEntry>,
+    context_type => ShardedMapV2NodeInferredCopyFromContext,
+    context_key => "icf.map2node",
+}
+
 impl_typed_hash! {
     hash_type => TestManifestId,
     thrift_hash_type => thrift::id::TestManifestId,
@@ -963,6 +987,12 @@ mod test {
             id.blobstore_key(),
             format!("redactionkeylist.blake2.{}", id)
         );
+
+        let id = ShardedMapV2NodeInferredCopyFromId::from_byte_array([1; 32]);
+        assert_eq!(id.blobstore_key(), format!("icf.map2node.blake2.{}", id));
+
+        let id = InferredCopyFromId::from_byte_array([1; 32]);
+        assert_eq!(id.blobstore_key(), format!("icf.blake2.{}", id));
     }
 
     #[mononoke::test]
@@ -1061,5 +1091,10 @@ mod test {
         let serialized = serde_json::to_string(&id).unwrap();
         let deserialized = serde_json::from_str(&serialized).unwrap();
         assert_eq!(id, deserialized);
+
+        let id = InferredCopyFromId::from_byte_array([1; 32]);
+        let serialized = serde_json::to_string(&id).unwrap();
+        let deserialized = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(id, deserialized);
     }
 }