backend: Implement sending notification email when a new version is published

Author: paolobarbolini

src/controllers/krate/publish.rs

@@ -195,7 +195,8 @@ pub fn publish(req: &mut dyn RequestExt) -> EndpointResult {
 
         let hex_cksum = cksum.encode_hex::<String>();
 
-        // Register this crate in our local git repo.
+        // Register this crate in our local git repo and send notification emails
+        // to owners who haven't opted out them.
         let git_crate = git::Crate {
             name: name.0,
             vers: vers.to_string(),
@@ -205,7 +206,8 @@ pub fn publish(req: &mut dyn RequestExt) -> EndpointResult {
             yanked: Some(false),
             links,
         };
-        git::add_crate(git_crate).enqueue(&conn)?;
+        let emails = krate.owners_with_notification_email(&conn)?;
+        git::add_crate(git_crate, emails, user.name, verified_email_address).enqueue(&conn)?;
 
         // The `other` field on `PublishWarnings` was introduced to handle a temporary warning
         // that is no longer needed. As such, crates.io currently does not return any `other`

src/email.rs

@@ -30,7 +30,7 @@ pub fn init_config_vars() -> Option<MailgunConfigVars> {
 }
 
 fn build_email(
-    recipient: &str,
+    recipients: &[&str],
     subject: &str,
     body: &str,
     mailgun_config: &Option<MailgunConfigVars>,
@@ -40,11 +40,11 @@ fn build_email(
         .map(|s| s.smtp_login.as_str())
         .unwrap_or("test@localhost");
 
-    let email = Message::builder()
-        .to(recipient.parse()?)
-        .from(sender.parse()?)
-        .subject(subject)
-        .body(body)?;
+    let mut builder = Message::builder();
+    for recipient in recipients {
+        builder = builder.to(recipient.parse()?);
+    }
+    let email = builder.from(sender.parse()?).subject(subject).body(body)?;
 
     Ok(email)
 }
@@ -79,7 +79,7 @@ https://{}/confirm/{}",
         token
     );
 
-    send_email(email, subject, &body)
+    send_email(&[email], subject, &body)
 }
 
 /// Attempts to send a crate owner invitation email. Swallows all errors.
@@ -99,12 +99,51 @@ or go to https://{domain}/me/pending-invites to manage all of your crate ownersh
         domain = crate::config::domain_name()
     );
 
-    let _ = send_email(email, subject, &body);
+    let _ = send_email(&[email], subject, &body);
+}
+
+/// Attempts to send a new crate version published notification to crate owners. Swallows all errors.
+pub fn notify_owners(
+    emails: &[&str],
+    crate_name: &str,
+    crate_version: &str,
+    publisher_name: Option<&str>,
+    publisher_email: &str,
+) {
+    let subject = format!(
+        "Crate {} ({}) published to crates.io",
+        crate_name, crate_version
+    );
+    let body = format!(
+        "A crate you have publish access to has recently released a new version.
+
+Crate: {} ({})
+Published by: {} <{}>
+Published at: {}
+
+If this publish is expected, you do not need to take further action.
+Only if this publish is unexpected, please take immediate steps to secure your account:
+
+* If you suspect your GitHub account was compromised, change your password
+* Revoke your API Token
+* Yank the version of the crate reported in this email
+* Report this incident to RustSec https://rustsec.org
+
+To stop receiving these messages, update your email notification settings at https://{domain}/me",
+        crate_name,
+        crate_version,
+        publisher_name.unwrap_or("(unknown username)"),
+        publisher_email,
+        chrono::Utc::now().to_rfc2822(),
+        domain = crate::config::domain_name()
+    );
+
+    let _ = send_email(emails, &subject, &body);
 }
 
-fn send_email(recipient: &str, subject: &str, body: &str) -> AppResult<()> {
+fn send_email(recipients: &[&str], subject: &str, body: &str) -> AppResult<()> {
     let mailgun_config = init_config_vars();
-    let email = build_email(recipient, subject, body, &mailgun_config)?;
+    let email = build_email(recipients, subject, body, &mailgun_config)?;
 
     match mailgun_config {
         Some(mailgun_config) => {
@@ -137,7 +176,7 @@ mod tests {
     #[test]
     fn sending_to_invalid_email_fails() {
         let result = send_email(
-            "String.Format(\"{0}.{1}@live.com\", FirstName, LastName)",
+            &["String.Format(\"{0}.{1}@live.com\", FirstName, LastName)"],
             "test",
             "test",
         );
@@ -146,7 +185,7 @@ mod tests {
 
     #[test]
     fn sending_to_valid_email_succeeds() {
-        let result = send_email("[email protected]", "test", "test");
+        let result = send_email(&["[email protected]"], "test", "test");
         assert_ok!(result);
     }
 }

src/git.rs

@@ -8,6 +8,7 @@ use tempfile::{Builder, TempDir};
 use url::Url;
 
 use crate::background_jobs::Environment;
+use crate::email::notify_owners;
 use crate::models::{DependencyKind, Version};
 use crate::schema::versions;
 
@@ -266,7 +267,13 @@ impl Repository {
 }
 
 #[swirl::background_job]
-pub fn add_crate(env: &Environment, krate: Crate) -> Result<(), PerformError> {
+pub fn add_crate(
+    env: &Environment,
+    krate: Crate,
+    owners_emails: Vec<String>,
+    publisher_name: Option<String>,
+    publisher_email: String,
+) -> Result<(), PerformError> {
     use std::io::prelude::*;
 
     let repo = env.lock_index()?;
@@ -279,8 +286,19 @@ pub fn add_crate(env: &Environment, krate: Crate) -> Result<(), PerformError> {
     file.write_all(b"\n")?;
 
     let message: String = format!("Updating crate `{}#{}`", krate.name, krate.vers);
-
-    repo.commit_and_push(&message, &repo.relative_index_file(&krate.name))
+    repo.commit_and_push(&message, &repo.relative_index_file(&krate.name))?;
+
+    // Notify crate owners of this new version being published
+    let emails = owners_emails.iter().map(AsRef::as_ref).collect::<Vec<_>>();
+    notify_owners(
+        &emails,
+        &krate.name,
+        &krate.vers,
+        publisher_name.as_deref(),
+        &publisher_email,
+    );
+
+    Ok(())
 }
 
 /// Yanks or unyanks a crate version. This requires finding the index

src/models/krate.rs

@@ -431,6 +431,17 @@ impl Crate {
         Ok(users.chain(teams).collect())
     }
 
+    pub fn owners_with_notification_email(&self, conn: &PgConnection) -> QueryResult<Vec<String>> {
+        CrateOwner::by_owner_kind(OwnerKind::User)
+            .filter(crate_owners::crate_id.eq(self.id))
+            .filter(crate_owners::email_notifications.eq(true))
+            .inner_join(emails::table.on(crate_owners::owner_id.eq(emails::user_id)))
+            .filter(emails::verified.eq(true))
+            .select(emails::email)
+            .distinct()
+            .load(conn)
+    }
+
     pub fn owner_add(
         &self,
         app: &App,

src/tests/krate.rs

@@ -1323,7 +1323,7 @@ fn new_krate_records_verified_email() {
             .select(versions_published_by::email)
             .first(conn)
             .unwrap();
-        assert_eq!(email, "[email protected]");
+        assert_eq!(email, "something+foo@example.com");
     });
 }
 

src/tests/owners.rs

@@ -82,6 +82,25 @@ impl MockCookieUser {
     fn list_invitations(&self) -> InvitationListResponse {
         self.get("/api/v1/me/crate_owner_invitations").good()
     }
+
+    fn set_email_notifications(&self, krate_id: i32, email_notifications: bool) {
+        let body = json!([
+            {
+                "id": krate_id,
+                "email_notifications": email_notifications,
+            }
+        ]);
+
+        #[derive(Deserialize)]
+        struct Empty {}
+
+        let _: Empty = self
+            .put(
+                "/api/v1/me/email_notifications",
+                body.to_string().as_bytes(),
+            )
+            .good();
+    }
 }
 
 #[test]
@@ -424,3 +443,40 @@ fn highest_gh_id_is_most_recent_account_we_know_of() {
     let json = invited_user.list_invitations();
     assert_eq!(json.crate_owner_invitations.len(), 1);
 }
+
+#[test]
+fn test_list_owners_with_notification_email() {
+    let (app, _, owner, owner_token) = TestApp::init().with_token();
+    let owner = owner.as_model();
+
+    let krate_name = "notification_crate";
+    let user_name = "notification_user";
+
+    let new_user = app.db_new_user(user_name);
+    let krate = app.db(|conn| CrateBuilder::new(krate_name, owner.id).expect_build(conn));
+
+    // crate author gets notified
+    let (owners_notification, email) = app.db(|conn| {
+        let owners_notification = krate.owners_with_notification_email(conn).unwrap();
+        let email = owner.verified_email(conn).unwrap().unwrap();
+        (owners_notification, email)
+    });
+    assert_eq!(owners_notification, [email.clone()]);
+
+    // crate author and the new crate owner get notified
+    owner_token.add_named_owner(krate_name, user_name).good();
+    new_user.accept_ownership_invitation(&krate.name, krate.id);
+
+    let (owners_notification, new_user_email) = app.db(|conn| {
+        let new_user_email = new_user.as_model().verified_email(conn).unwrap().unwrap();
+        let owners_notification = krate.owners_with_notification_email(conn).unwrap();
+        (owners_notification, new_user_email)
+    });
+    assert_eq!(owners_notification, [email.clone(), new_user_email]);
+
+    // crate owners who disabled notifications don't get notified
+    new_user.set_email_notifications(krate.id, false);
+
+    let owners_notification = app.db(|conn| krate.owners_with_notification_email(conn).unwrap());
+    assert_eq!(owners_notification, [email]);
+}

src/tests/user.rs

@@ -462,7 +462,7 @@ fn test_email_get_and_put() {
     let (_app, _anon, user) = TestApp::init().with_user();
 
     let json = user.show_me();
-    assert_eq!(json.user.email.unwrap(), "[email protected]");
+    assert_eq!(json.user.email.unwrap(), "something+foo@example.com");
 
     user.update_email("[email protected]");
 

src/tests/util.rs

@@ -138,7 +138,7 @@ impl TestApp {
         use diesel::prelude::*;
 
         let user = self.db(|conn| {
-            let email = "[email protected]";
+            let email = format!("something+{}@example.com", username);
 
             let user = crate::new_user(username)
                 .create_or_update(None, conn)