[plume-common]Implement ActivityPub related function using activitystreams 0.7

plume-common/src/activity_pub/inbox.rs

@@ -274,6 +274,84 @@ where
         }
     }
 
+    /// Registers an handler on this Inbox.
+    pub fn with07<A, V, M>(self, proxy: Option<&reqwest::Proxy>) -> Self
+    where
+        A: AsActor<&'a C> + FromId07<C, Error = E>,
+        V: activitystreams::markers::Activity + serde::de::DeserializeOwned,
+        M: AsObject07<A, V, &'a C, Error = E> + FromId07<C, Error = E>,
+        M::Output: Into<R>,
+    {
+        if let Self::NotHandled(ctx, mut act, e) = self {
+            if serde_json::from_value::<V>(act.clone()).is_ok() {
+                let act_clone = act.clone();
+                let act_id = match act_clone["id"].as_str() {
+                    Some(x) => x,
+                    None => return Self::NotHandled(ctx, act, InboxError::InvalidID),
+                };
+
+                // Get the actor ID
+                let actor_id = match get_id(act["actor"].clone()) {
+                    Some(x) => x,
+                    None => return Self::NotHandled(ctx, act, InboxError::InvalidActor(None)),
+                };
+
+                if Self::is_spoofed_activity(&actor_id, &act) {
+                    return Self::NotHandled(ctx, act, InboxError::InvalidObject(None));
+                }
+
+                // Transform this actor to a model (see FromId for details about the from_id function)
+                let actor = match A::from_id(
+                    ctx,
+                    &actor_id,
+                    serde_json::from_value(act["actor"].clone()).ok(),
+                    proxy,
+                ) {
+                    Ok(a) => a,
+                    // If the actor was not found, go to the next handler
+                    Err((json, e)) => {
+                        if let Some(json) = json {
+                            act["actor"] = json;
+                        }
+                        return Self::NotHandled(ctx, act, InboxError::InvalidActor(Some(e)));
+                    }
+                };
+
+                // Same logic for "object"
+                let obj_id = match get_id(act["object"].clone()) {
+                    Some(x) => x,
+                    None => return Self::NotHandled(ctx, act, InboxError::InvalidObject(None)),
+                };
+                let obj = match M::from_id(
+                    ctx,
+                    &obj_id,
+                    serde_json::from_value(act["object"].clone()).ok(),
+                    proxy,
+                ) {
+                    Ok(o) => o,
+                    Err((json, e)) => {
+                        if let Some(json) = json {
+                            act["object"] = json;
+                        }
+                        return Self::NotHandled(ctx, act, InboxError::InvalidObject(Some(e)));
+                    }
+                };
+
+                // Handle the activity
+                match obj.activity(ctx, actor, act_id) {
+                    Ok(res) => Self::Handled(res.into()),
+                    Err(e) => Self::Failed(e),
+                }
+            } else {
+                // If the Activity type is not matching the expected one for
+                // this handler, try with the next one.
+                Self::NotHandled(ctx, act, e)
+            }
+        } else {
+            self
+        }
+    }
+
     /// Transforms the inbox in a `Result`
     pub fn done(self) -> Result<R, E> {
         match self {
@@ -384,6 +462,72 @@ pub trait FromId<C>: Sized {
 
     fn get_sender() -> &'static dyn Signer;
 }
+/// A trait for ActivityPub objects that can be retrieved or constructed from ID.
+///
+/// The two functions to implement are `from_activity` to create (and save) a new object
+/// of this type from its AP representation, and `from_db` to try to find it in the database
+/// using its ID.
+///
+/// When dealing with the "object" field of incoming activities, `Inbox` will try to see if it is
+/// a full object, and if so, save it with `from_activity`. If it is only an ID, it will try to find
+/// it in the database with `from_db`, and otherwise dereference (fetch) the full object and parse it
+/// with `from_activity`.
+pub trait FromId07<C>: Sized {
+    /// The type representing a failure
+    type Error: From<InboxError<Self::Error>> + Debug;
+
+    /// The ActivityPub object type representing Self
+    type Object: activitystreams::markers::Object + serde::de::DeserializeOwned;
+
+    /// Tries to get an instance of `Self` from an ActivityPub ID.
+    ///
+    /// # Parameters
+    ///
+    /// - `ctx`: a context to get this instance (= a database in which to search)
+    /// - `id`: the ActivityPub ID of the object to find
+    /// - `object`: optional object that will be used if the object was not found in the database
+    ///   If absent, the ID will be dereferenced.
+    fn from_id(
+        ctx: &C,
+        id: &str,
+        object: Option<Self::Object>,
+        proxy: Option<&reqwest::Proxy>,
+    ) -> Result<Self, (Option<serde_json::Value>, Self::Error)> {
+        match Self::from_db(ctx, id) {
+            Ok(x) => Ok(x),
+            _ => match object {
+                Some(o) => Self::from_activity(ctx, o).map_err(|e| (None, e)),
+                None => Self::from_activity(ctx, Self::deref(id, proxy.cloned())?)
+                    .map_err(|e| (None, e)),
+            },
+        }
+    }
+
+    /// Dereferences an ID
+    fn deref(
+        id: &str,
+        proxy: Option<reqwest::Proxy>,
+    ) -> Result<Self::Object, (Option<serde_json::Value>, Self::Error)> {
+        request::get(id, Self::get_sender(), proxy)
+            .map_err(|_| (None, InboxError::DerefError))
+            .and_then(|mut r| {
+                let json: serde_json::Value = r
+                    .json()
+                    .map_err(|_| (None, InboxError::InvalidObject(None)))?;
+                serde_json::from_value(json.clone())
+                    .map_err(|_| (Some(json), InboxError::InvalidObject(None)))
+            })
+            .map_err(|(json, e)| (json, e.into()))
+    }
+
+    /// Builds a `Self` from its ActivityPub representation
+    fn from_activity(ctx: &C, activity: Self::Object) -> Result<Self, Self::Error>;
+
+    /// Tries to find a `Self` with a given ID (`id`), using `ctx` (a database)
+    fn from_db(ctx: &C, id: &str) -> Result<Self, Self::Error>;
+
+    fn get_sender() -> &'static dyn Signer;
+}
 
 /// Should be implemented by anything representing an ActivityPub actor.
 ///
@@ -543,6 +687,146 @@ where
     fn activity(self, ctx: C, actor: A, id: &str) -> Result<Self::Output, Self::Error>;
 }
 
+/// Should be implemented by anything representing an ActivityPub object.
+///
+/// # Type parameters
+///
+/// - `A`: the actor type
+/// - `V`: the ActivityPub verb/activity
+/// - `O`: the ActivityPub type of the Object for this activity (usually the type corresponding to `Self`)
+/// - `C`: the context needed to handle the activity (usually a database connection)
+///
+/// # Example
+///
+/// An implementation of AsObject that handles Note creation by an Account model,
+/// representing the Note by a Message type, without any specific context.
+///
+/// ```rust
+/// # extern crate activitypub;
+/// # use activitypub::{activity::Create, actor::Person, object::Note};
+/// # use plume_common::activity_pub::inbox::{AsActor, AsObject, FromId};
+/// # use plume_common::activity_pub::sign::{gen_keypair, Error as SignError, Result as SignResult, Signer};
+/// # use openssl::{hash::MessageDigest, pkey::PKey, rsa::Rsa};
+/// # use once_cell::sync::Lazy;
+/// #
+/// # static MY_SIGNER: Lazy<MySigner> = Lazy::new(|| MySigner::new());
+/// #
+/// # struct MySigner {
+/// #     public_key: String,
+/// #     private_key: String,
+/// # }
+/// #
+/// # impl MySigner {
+/// #     fn new() -> Self {
+/// #         let (pub_key, priv_key) = gen_keypair();
+/// #         Self {
+/// #             public_key: String::from_utf8(pub_key).unwrap(),
+/// #             private_key: String::from_utf8(priv_key).unwrap(),
+/// #         }
+/// #     }
+/// # }
+/// #
+/// # impl Signer for MySigner {
+/// #     fn get_key_id(&self) -> String {
+/// #         "mysigner".into()
+/// #     }
+/// #
+/// #     fn sign(&self, to_sign: &str) -> SignResult<Vec<u8>> {
+/// #         let key = PKey::from_rsa(Rsa::private_key_from_pem(self.private_key.as_ref()).unwrap())
+/// #             .unwrap();
+/// #         let mut signer = openssl::sign::Signer::new(MessageDigest::sha256(), &key).unwrap();
+/// #         signer.update(to_sign.as_bytes()).unwrap();
+/// #         signer.sign_to_vec().map_err(|_| SignError())
+/// #     }
+/// #
+/// #     fn verify(&self, data: &str, signature: &[u8]) -> SignResult<bool> {
+/// #         let key = PKey::from_rsa(Rsa::public_key_from_pem(self.public_key.as_ref()).unwrap())
+/// #             .unwrap();
+/// #         let mut verifier = openssl::sign::Verifier::new(MessageDigest::sha256(), &key).unwrap();
+/// #         verifier.update(data.as_bytes()).unwrap();
+/// #         verifier.verify(&signature).map_err(|_| SignError())
+/// #     }
+/// # }
+/// #
+/// # struct Account;
+/// # impl FromId<()> for Account {
+/// #     type Error = ();
+/// #     type Object = Person;
+/// #
+/// #     fn from_db(_: &(), _id: &str) -> Result<Self, Self::Error> {
+/// #         Ok(Account)
+/// #     }
+/// #
+/// #     fn from_activity(_: &(), obj: Person) -> Result<Self, Self::Error> {
+/// #         Ok(Account)
+/// #     }
+/// #
+/// #     fn get_sender() -> &'static dyn Signer {
+/// #         &*MY_SIGNER
+/// #     }
+/// # }
+/// # impl AsActor<()> for Account {
+/// #    fn get_inbox_url(&self) -> String {
+/// #        String::new()
+/// #    }
+/// #    fn is_local(&self) -> bool { false }
+/// # }
+/// #[derive(Debug)]
+/// struct Message {
+///     text: String,
+/// }
+///
+/// impl FromId<()> for Message {
+///     type Error = ();
+///     type Object = Note;
+///
+///     fn from_db(_: &(), _id: &str) -> Result<Self, Self::Error> {
+///         Ok(Message { text: "From DB".into() })
+///     }
+///
+///     fn from_activity(_: &(), obj: Note) -> Result<Self, Self::Error> {
+///         Ok(Message { text: obj.object_props.content_string().map_err(|_| ())? })
+///     }
+///
+///     fn get_sender() -> &'static dyn Signer {
+///         &*MY_SIGNER
+///     }
+/// }
+///
+/// impl AsObject<Account, Create, ()> for Message {
+///     type Error = ();
+///     type Output = ();
+///
+///     fn activity(self, _: (), _actor: Account, _id: &str) -> Result<(), ()> {
+///         println!("New Note: {:?}", self);
+///         Ok(())
+///     }
+/// }
+/// ```
+pub trait AsObject07<A, V, C>
+where
+    V: activitystreams::markers::Activity,
+{
+    /// What kind of error is returned when something fails
+    type Error;
+
+    /// What is returned by `AsObject::activity`, if anything is returned
+    type Output = ();
+
+    /// Handle a specific type of activity dealing with this type of objects.
+    ///
+    /// The implementations should check that the actor is actually authorized
+    /// to perform this action.
+    ///
+    /// # Parameters
+    ///
+    /// - `self`: the object on which the activity acts
+    /// - `ctx`: the context passed to `Inbox::handle`
+    /// - `actor`: the actor who did this activity
+    /// - `id`: the ID of this activity
+    fn activity(self, ctx: C, actor: A, id: &str) -> Result<Self::Output, Self::Error>;
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;