From 4e6f3209d5e5a62722590defc58a5a59c57b71ec Mon Sep 17 00:00:00 2001 From: Trinity Pointard Date: Sat, 20 Oct 2018 08:44:33 +0200 Subject: [PATCH] Normalize panic message Change all unwrap to expect Normalize expect's messages Don't panic where it could be avoided easily --- plume-cli/src/main.rs | 2 +- plume-common/src/activity_pub/inbox.rs | 2 +- plume-common/src/activity_pub/mod.rs | 15 ++- plume-common/src/activity_pub/request.rs | 28 ++--- plume-common/src/activity_pub/sign.rs | 15 ++- plume-models/src/blogs.rs | 61 ++++++----- plume-models/src/comments.rs | 62 +++++------ plume-models/src/follows.rs | 37 ++++--- plume-models/src/instance.rs | 20 ++-- plume-models/src/lib.rs | 16 +-- plume-models/src/likes.rs | 26 ++--- plume-models/src/medias.rs | 12 +- plume-models/src/mentions.rs | 8 +- plume-models/src/notifications.rs | 8 +- plume-models/src/posts.rs | 51 +++++---- plume-models/src/reshares.rs | 30 ++--- plume-models/src/tags.rs | 5 +- plume-models/src/users.rs | 133 ++++++++++++----------- 18 files changed, 279 insertions(+), 252 deletions(-) diff --git a/plume-cli/src/main.rs b/plume-cli/src/main.rs index d44b4c13..a060c7c9 100644 --- a/plume-cli/src/main.rs +++ b/plume-cli/src/main.rs @@ -27,7 +27,7 @@ fn main() { match matches.subcommand() { ("instance", Some(args)) => instance::run(args, &conn.expect("Couldn't connect to the database.")), ("users", Some(args)) => users::run(args, &conn.expect("Couldn't connect to the database.")), - _ => app.print_help().unwrap() + _ => app.print_help().expect("Couldn't print help") }; } diff --git a/plume-common/src/activity_pub/inbox.rs b/plume-common/src/activity_pub/inbox.rs index 4a302a13..f9f0e8b9 100644 --- a/plume-common/src/activity_pub/inbox.rs +++ b/plume-common/src/activity_pub/inbox.rs @@ -17,7 +17,7 @@ pub trait FromActivity: Sized { fn try_from_activity(conn: &C, act: Create) -> bool { if let Ok(obj) = act.create_props.object_object() { - Self::from_activity(conn, obj, act.create_props.actor_link::().unwrap()); + Self::from_activity(conn, obj, act.create_props.actor_link::().expect("FromActivity::try_from_activity: id not found error")); true } else { false diff --git a/plume-common/src/activity_pub/mod.rs b/plume-common/src/activity_pub/mod.rs index 03e05db7..c96b5ade 100644 --- a/plume-common/src/activity_pub/mod.rs +++ b/plume-common/src/activity_pub/mod.rs @@ -82,14 +82,13 @@ impl<'a, 'r> FromRequest<'a, 'r> for ApRequest { "application/ld+json" => Outcome::Success(ApRequest), "text/html" => Outcome::Forward(true), _ => Outcome::Forward(false) - }).fold(Outcome::Forward(false), |out, ct| if out.is_success() || (out.is_forward() && out.clone().forwarded().unwrap()) { + }).fold(Outcome::Forward(false), |out, ct| if out.clone().forwarded().unwrap_or(out.is_success()) { out } else { ct }).map_forward(|_| ())).unwrap_or(Outcome::Forward(())) } } - pub fn broadcast(sender: &S, act: A, to: Vec) { let boxes = to.into_iter() .filter(|u| !u.is_local()) @@ -97,7 +96,8 @@ pub fn broadcast(send .collect::>() .unique(); - let mut act = serde_json::to_value(act).unwrap(); + + let mut act = serde_json::to_value(act).expect("activity_pub::broadcast: serialization error"); act["@context"] = context(); let signed = act.sign(sender); @@ -112,7 +112,14 @@ pub fn broadcast(send .body(signed.to_string()) .send(); match res { - Ok(mut r) => println!("Successfully sent activity to inbox ({})\n\n{:?}", inbox, r.text().unwrap()), + Ok(mut r) => { + println!("Successfully sent activity to inbox ({})", inbox); + if let Ok(response) = r.text() { + println!("Response: \"{:?}\"\n\n", response) + } else { + println!("Error while reading response") + } + }, Err(e) => println!("Error while sending to inbox ({:?})", e) } } diff --git a/plume-common/src/activity_pub/request.rs b/plume-common/src/activity_pub/request.rs index a4ae9dc1..0ba2a5ee 100644 --- a/plume-common/src/activity_pub/request.rs +++ b/plume-common/src/activity_pub/request.rs @@ -14,30 +14,30 @@ pub struct Digest(String); impl Digest { pub fn digest(body: String) -> HeaderValue { - let mut hasher = Hasher::new(MessageDigest::sha256()).unwrap(); - hasher.update(&body.into_bytes()[..]).unwrap(); - let res = base64::encode(&hasher.finish().unwrap()); - HeaderValue::from_str(&format!("SHA-256={}", res)).unwrap() + let mut hasher = Hasher::new(MessageDigest::sha256()).expect("Digest::digest: initialization error"); + hasher.update(&body.into_bytes()[..]).expect("Digest::digest: content insertion error"); + let res = base64::encode(&hasher.finish().expect("Digest::digest: finalizing error")); + HeaderValue::from_str(&format!("SHA-256={}", res)).expect("Digest::digest: header creation error") } pub fn verify(&self, body: String) -> bool { if self.algorithm()=="SHA-256" { - let mut hasher = Hasher::new(MessageDigest::sha256()).unwrap(); - hasher.update(&body.into_bytes()).unwrap(); - self.value().deref()==hasher.finish().unwrap().deref() + let mut hasher = Hasher::new(MessageDigest::sha256()).expect("Digest::digest: initialization error"); + hasher.update(&body.into_bytes()).expect("Digest::digest: content insertion error"); + self.value().deref()==hasher.finish().expect("Digest::digest: finalizing error").deref() } else { false //algorithm not supported } } pub fn algorithm(&self) -> &str { - let pos = self.0.find('=').unwrap(); + let pos = self.0.find('=').expect("Digest::algorithm: invalid header error"); &self.0[..pos] } pub fn value(&self) -> Vec { - let pos = self.0.find('=').unwrap()+1; - base64::decode(&self.0[pos..]).unwrap() + let pos = self.0.find('=').expect("Digest::value: invalid header error")+1; + base64::decode(&self.0[pos..]).expect("Digest::value: invalid encoding error") } pub fn from_header(dig: &str) -> Result { @@ -60,13 +60,13 @@ pub fn headers() -> HeaderMap { let mut headers = HeaderMap::new(); headers.insert(USER_AGENT, HeaderValue::from_static(PLUME_USER_AGENT)); - headers.insert(DATE, HeaderValue::from_str(&date).unwrap()); - headers.insert(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::>().join(", ")).unwrap()); + headers.insert(DATE, HeaderValue::from_str(&date).expect("request::headers: date error")); + headers.insert(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::>().join(", ")).expect("request::headers: accept error")); headers } pub fn signature(signer: &S, headers: HeaderMap) -> HeaderValue { - let signed_string = headers.iter().map(|(h,v)| format!("{}: {}", h.as_str().to_lowercase(), v.to_str().unwrap())).collect::>().join("\n"); + let signed_string = headers.iter().map(|(h,v)| format!("{}: {}", h.as_str().to_lowercase(), v.to_str().expect("request::signature: invalid header error"))).collect::>().join("\n"); let signed_headers = headers.iter().map(|(h,_)| h.as_str()).collect::>().join(" ").to_lowercase(); let data = signer.sign(signed_string); @@ -77,5 +77,5 @@ pub fn signature(signer: &S, headers: HeaderMap) -> HeaderValue { key_id = signer.get_key_id(), signed_headers = signed_headers, signature = sign - )).unwrap() + )).expect("request::signature: signature header error") } diff --git a/plume-common/src/activity_pub/sign.rs b/plume-common/src/activity_pub/sign.rs index 427f50f2..3abfc7d8 100644 --- a/plume-common/src/activity_pub/sign.rs +++ b/plume-common/src/activity_pub/sign.rs @@ -12,9 +12,12 @@ use serde_json; /// Returns (public key, private key) pub fn gen_keypair() -> (Vec, Vec) { - let keypair = Rsa::generate(2048).unwrap(); - let keypair = PKey::from_rsa(keypair).unwrap(); - (keypair.public_key_to_pem().unwrap(), keypair.private_key_to_pem_pkcs8().unwrap()) + let keypair = Rsa::generate(2048).expect("sign::gen_keypair: key generation error"); + let keypair = PKey::from_rsa(keypair).expect("sign::gen_keypair: parsing error"); + ( + keypair.public_key_to_pem().expect("sign::gen_keypair: public key encoding error"), + keypair.private_key_to_pem_pkcs8().expect("sign::gen_keypair: private key encoding error") + ) } pub trait Signer { @@ -101,7 +104,7 @@ pub fn verify_http_headers(sender: &S, all_headers: if sig_header.is_none() { return SignatureValidity::Absent } - let sig_header = sig_header.unwrap(); + let sig_header = sig_header.expect("sign::verify_http_headers: unreachable"); let mut _key_id = None; let mut _algorithm = None; @@ -120,8 +123,8 @@ pub fn verify_http_headers(sender: &S, all_headers: if signature.is_none() || headers.is_none() {//missing part of the header return SignatureValidity::Invalid } - let headers = headers.unwrap().split_whitespace().collect::>(); - let signature = signature.unwrap(); + let headers = headers.expect("sign::verify_http_headers: unreachable").split_whitespace().collect::>(); + let signature = signature.expect("sign::verify_http_headers: unreachable"); let h = headers.iter() .map(|header| (header,all_headers.get_one(header))) .map(|(header, value)| format!("{}: {}", header.to_lowercase(), value.unwrap_or(""))) diff --git a/plume-models/src/blogs.rs b/plume-models/src/blogs.rs index ec1e7fde..09497ab0 100644 --- a/plume-models/src/blogs.rs +++ b/plume-models/src/blogs.rs @@ -65,7 +65,7 @@ impl Blog { find_by!(blogs, find_by_name, actor_id as String, instance_id as i32); pub fn get_instance(&self, conn: &Connection) -> Instance { - Instance::get(conn, self.instance_id).expect("Couldn't find instance") + Instance::get(conn, self.instance_id).expect("Blog::get_instance: instance not found error") } pub fn list_authors(&self, conn: &Connection) -> Vec { @@ -74,7 +74,7 @@ impl Blog { let authors_ids = blog_authors::table.filter(blog_authors::blog_id.eq(self.id)).select(blog_authors::author_id); users::table.filter(users::id.eq_any(authors_ids)) .load::(conn) - .expect("Couldn't load authors of a blog") + .expect("Blog::list_authors: author loading error") } pub fn find_for_author(conn: &Connection, author_id: i32) -> Vec { @@ -82,7 +82,7 @@ impl Blog { let author_ids = blog_authors::table.filter(blog_authors::author_id.eq(author_id)).select(blog_authors::blog_id); blogs::table.filter(blogs::id.eq_any(author_ids)) .load::(conn) - .expect("Couldn't load blogs ") + .expect("Blog::find_for_author: blog loading error") } pub fn find_local(conn: &Connection, name: String) -> Option { @@ -91,9 +91,9 @@ impl Blog { pub fn find_by_fqn(conn: &Connection, fqn: String) -> Option { if fqn.contains("@") { // remote blog - match Instance::find_by_domain(conn, String::from(fqn.split("@").last().unwrap())) { + match Instance::find_by_domain(conn, String::from(fqn.split("@").last().expect("Blog::find_by_fqn: unreachable"))) { Some(instance) => { - match Blog::find_by_name(conn, String::from(fqn.split("@").nth(0).unwrap()), instance.id) { + match Blog::find_by_name(conn, String::from(fqn.split("@").nth(0).expect("Blog::find_by_fqn: unreachable")), instance.id) { Some(u) => Some(u), None => Blog::fetch_from_webfinger(conn, fqn) } @@ -107,7 +107,7 @@ impl Blog { fn fetch_from_webfinger(conn: &Connection, acct: String) -> Option { match resolve(acct.clone(), *USE_HTTPS) { - Ok(wf) => wf.links.into_iter().find(|l| l.mime_type == Some(String::from("application/activity+json"))).and_then(|l| Blog::fetch_from_url(conn, l.href.expect("No href for AP WF link"))), + Ok(wf) => wf.links.into_iter().find(|l| l.mime_type == Some(String::from("application/activity+json"))).and_then(|l| Blog::fetch_from_url(conn, l.href.expect("Blog::fetch_from_webfinger: href not found error"))), Err(details) => { println!("{:?}", details); None @@ -118,15 +118,15 @@ impl Blog { fn fetch_from_url(conn: &Connection, url: String) -> Option { let req = Client::new() .get(&url[..]) - .header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::>().join(", ")).unwrap()) + .header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::>().join(", ")).expect("Blog::fetch_from_url: accept_header generation error")) .send(); match req { Ok(mut res) => { - let text = &res.text().unwrap(); - let ap_sign: ApSignature = serde_json::from_str(text).unwrap(); - let mut json: CustomGroup = serde_json::from_str(text).unwrap(); + let text = &res.text().expect("Blog::fetch_from_url: body reading error"); + let ap_sign: ApSignature = serde_json::from_str(text).expect("Blog::fetch_from_url: body parsing error"); + let mut json: CustomGroup = serde_json::from_str(text).expect("Blog::fetch_from_url: body parsing error"); json.custom_props = ap_sign; // without this workaround, publicKey is not correctly deserialized - Some(Blog::from_activity(conn, json, Url::parse(url.as_ref()).unwrap().host_str().unwrap().to_string())) + Some(Blog::from_activity(conn, json, Url::parse(url.as_ref()).expect("Blog::fetch_from_url: url parsing error").host_str().expect("Blog::fetch_from_url: host extraction error").to_string())) }, Err(_) => None } @@ -188,26 +188,26 @@ impl Blog { if self.outbox_url.len() == 0 { diesel::update(self) .set(blogs::outbox_url.eq(instance.compute_box(BLOG_PREFIX, self.actor_id.clone(), "outbox"))) - .execute(conn).expect("Couldn't update outbox URL"); + .execute(conn).expect("Blog::update_boxes: outbox update error"); } if self.inbox_url.len() == 0 { diesel::update(self) .set(blogs::inbox_url.eq(instance.compute_box(BLOG_PREFIX, self.actor_id.clone(), "inbox"))) - .execute(conn).expect("Couldn't update inbox URL"); + .execute(conn).expect("Blog::update_boxes: inbox update error"); } if self.ap_url.len() == 0 { diesel::update(self) .set(blogs::ap_url.eq(instance.compute_box(BLOG_PREFIX, self.actor_id.clone(), ""))) - .execute(conn).expect("Couldn't update AP URL"); + .execute(conn).expect("Blog::update_boxes: ap_url update error"); } } pub fn outbox(&self, conn: &Connection) -> ActivityStream { let mut coll = OrderedCollection::default(); - coll.collection_props.items = serde_json::to_value(self.get_activities(conn)).unwrap(); - coll.collection_props.set_total_items_u64(self.get_activities(conn).len() as u64).unwrap(); + coll.collection_props.items = serde_json::to_value(self.get_activities(conn)).expect("Blog::outbox: activity serialization error"); + coll.collection_props.set_total_items_u64(self.get_activities(conn).len() as u64).expect("Blog::outbox: count serialization error"); ActivityStream::new(coll) } @@ -216,7 +216,9 @@ impl Blog { } pub fn get_keypair(&self) -> PKey { - PKey::from_rsa(Rsa::private_key_from_pem(self.private_key.clone().unwrap().as_ref()).unwrap()).unwrap() + PKey::from_rsa(Rsa::private_key_from_pem(self.private_key.clone().expect("Blog::get_keypair: private key not found error").as_ref()) + .expect("Blog::get_keypair: pem parsing error")) + .expect("Blog::get_keypair: private key deserialization error") } pub fn webfinger(&self, conn: &Connection) -> Webfinger { @@ -248,9 +250,9 @@ impl Blog { pub fn from_url(conn: &Connection, url: String) -> Option { Blog::find_by_ap_url(conn, url.clone()).or_else(|| { - // The requested user was not in the DB + // The requested blog was not in the DB // We try to fetch it if it is remote - if Url::parse(url.as_ref()).unwrap().host_str().unwrap() != BASE_URL.as_str() { + if Url::parse(url.as_ref()).expect("Blog::from_url: ap_url parsing error").host_str().expect("Blog::from_url: host extraction error") != BASE_URL.as_str() { Blog::fetch_from_url(conn, url) } else { None @@ -267,7 +269,7 @@ impl Blog { } pub fn to_json(&self, conn: &Connection) -> serde_json::Value { - let mut json = serde_json::to_value(self).unwrap(); + let mut json = serde_json::to_value(self).expect("Blog::to_json: serialization error"); json["fqn"] = json!(self.get_fqn(conn)); json } @@ -303,16 +305,17 @@ impl sign::Signer for Blog { fn sign(&self, to_sign: String) -> Vec { let key = self.get_keypair(); - let mut signer = Signer::new(MessageDigest::sha256(), &key).unwrap(); - signer.update(to_sign.as_bytes()).unwrap(); - signer.sign_to_vec().unwrap() + let mut signer = Signer::new(MessageDigest::sha256(), &key).expect("Blog::sign: initialization error"); + signer.update(to_sign.as_bytes()).expect("Blog::sign: content insertion error"); + signer.sign_to_vec().expect("Blog::sign: finalization error") } fn verify(&self, data: String, signature: Vec) -> bool { - let key = PKey::from_rsa(Rsa::public_key_from_pem(self.public_key.as_ref()).unwrap()).unwrap(); - let mut verifier = Verifier::new(MessageDigest::sha256(), &key).unwrap(); - verifier.update(data.as_bytes()).unwrap(); - verifier.verify(&signature).unwrap() + let key = PKey::from_rsa(Rsa::public_key_from_pem(self.public_key.as_ref()).expect("Blog::verify: pem parsing error")) + .expect("Blog::verify: deserialization error"); + let mut verifier = Verifier::new(MessageDigest::sha256(), &key).expect("Blog::verify: initialization error"); + verifier.update(data.as_bytes()).expect("Blog::verify: content insertion error"); + verifier.verify(&signature).expect("Blog::verify: finalization error") } } @@ -332,8 +335,8 @@ impl NewBlog { inbox_url: String::from(""), instance_id: instance_id, ap_url: String::from(""), - public_key: String::from_utf8(pub_key).unwrap(), - private_key: Some(String::from_utf8(priv_key).unwrap()) + public_key: String::from_utf8(pub_key).expect("NewBlog::new_local: public key error"), + private_key: Some(String::from_utf8(priv_key).expect("NewBlog::new_local: private key error")) } } } diff --git a/plume-models/src/comments.rs b/plume-models/src/comments.rs index b7e2b756..0376f48b 100644 --- a/plume-models/src/comments.rs +++ b/plume-models/src/comments.rs @@ -53,11 +53,11 @@ impl Comment { find_by!(comments, find_by_ap_url, ap_url as String); pub fn get_author(&self, conn: &Connection) -> User { - User::get(conn, self.author_id).unwrap() + User::get(conn, self.author_id).expect("Comment::get_author: author error") } pub fn get_post(&self, conn: &Connection) -> Post { - Post::get(conn, self.post_id).unwrap() + Post::get(conn, self.post_id).expect("Comment::get_post: post error") } pub fn count_local(conn: &Connection) -> usize { @@ -65,17 +65,17 @@ impl Comment { let local_authors = users::table.filter(users::instance_id.eq(Instance::local_id(conn))).select(users::id); comments::table.filter(comments::author_id.eq_any(local_authors)) .load::(conn) - .expect("Couldn't load local comments") - .len() + .expect("Comment::count_local: loading error") + .len()// TODO count in database? } pub fn to_json(&self, conn: &Connection, others: &Vec) -> serde_json::Value { - let mut json = serde_json::to_value(self).unwrap(); + let mut json = serde_json::to_value(self).expect("Comment::to_json: serialization error"); json["author"] = self.get_author(conn).to_json(conn); let mentions = Mention::list_for_comment(conn, self.id).into_iter() .map(|m| m.get_mentioned(conn).map(|u| u.get_fqn(conn)).unwrap_or(String::new())) .collect::>(); - json["mentions"] = serde_json::to_value(mentions).unwrap(); + json["mentions"] = serde_json::to_value(mentions).expect("Comment::to_json: mention error"); json["responses"] = json!(others.into_iter() .filter(|c| c.in_response_to_id.map(|id| id == self.id).unwrap_or(false)) .map(|c| c.to_json(conn, others)) @@ -88,8 +88,8 @@ impl Comment { diesel::update(self) .set(comments::ap_url.eq(self.compute_id(conn))) .execute(conn) - .expect("Failed to update comment AP URL"); - Comment::get(conn, self.id).expect("Couldn't get the updated comment") + .expect("Comment::update_ap_url: update error"); + Comment::get(conn, self.id).expect("Comment::update_ap_url: get error") } else { self.clone() } @@ -102,53 +102,53 @@ impl Comment { pub fn into_activity(&self, conn: &Connection) -> Note { let (html, mentions) = utils::md_to_html(self.content.get().as_ref()); - let author = User::get(conn, self.author_id).unwrap(); + let author = User::get(conn, self.author_id).expect("Comment::into_activity: author error"); let mut note = Note::default(); let to = vec![Id::new(PUBLIC_VISIBILTY.to_string())]; - note.object_props.set_id_string(self.ap_url.clone().unwrap_or(String::new())).expect("NewComment::create: note.id error"); - note.object_props.set_summary_string(self.spoiler_text.clone()).expect("NewComment::create: note.summary error"); - note.object_props.set_content_string(html).expect("NewComment::create: note.content error"); - note.object_props.set_in_reply_to_link(Id::new(self.in_response_to_id.map_or_else(|| Post::get(conn, self.post_id).unwrap().ap_url, |id| { - let comm = Comment::get(conn, id).unwrap(); + note.object_props.set_id_string(self.ap_url.clone().unwrap_or(String::new())).expect("Comment::into_activity: id error"); + note.object_props.set_summary_string(self.spoiler_text.clone()).expect("Comment::into_activity: summary error"); + note.object_props.set_content_string(html).expect("Comment::into_activity: content error"); + note.object_props.set_in_reply_to_link(Id::new(self.in_response_to_id.map_or_else(|| Post::get(conn, self.post_id).expect("Comment::into_activity: post error").ap_url, |id| { + let comm = Comment::get(conn, id).expect("Comment::into_activity: comment error"); comm.ap_url.clone().unwrap_or(comm.compute_id(conn)) - }))).expect("NewComment::create: note.in_reply_to error"); - note.object_props.set_published_string(chrono::Utc::now().to_rfc3339()).expect("NewComment::create: note.published error"); - note.object_props.set_attributed_to_link(author.clone().into_id()).expect("NewComment::create: note.attributed_to error"); - note.object_props.set_to_link_vec(to.clone()).expect("NewComment::create: note.to error"); + }))).expect("Comment::into_activity: in_reply_to error"); + note.object_props.set_published_string(chrono::Utc::now().to_rfc3339()).expect("Comment::into_activity: published error"); + note.object_props.set_attributed_to_link(author.clone().into_id()).expect("Comment::into_activity: attributed_to error"); + note.object_props.set_to_link_vec(to.clone()).expect("Comment::into_activity: to error"); note.object_props.set_tag_link_vec(mentions.into_iter().map(|m| Mention::build_activity(conn, m)).collect::>()) - .expect("NewComment::create: note.tag error"); + .expect("Comment::into_activity: tag error"); note } pub fn create_activity(&self, conn: &Connection) -> Create { - let author = User::get(conn, self.author_id).unwrap(); + let author = User::get(conn, self.author_id).expect("Comment::create_activity: author error"); let note = self.into_activity(conn); let mut act = Create::default(); - act.create_props.set_actor_link(author.into_id()).expect("NewComment::create_acitivity: actor error"); - act.create_props.set_object_object(note.clone()).expect("NewComment::create_acitivity: object error"); - act.object_props.set_id_string(format!("{}/activity", self.ap_url.clone().unwrap())).expect("NewComment::create_acitivity: id error"); - act.object_props.set_to_link_vec(note.object_props.to_link_vec::().expect("WTF")).expect("NewComment::create_acitivity: to error"); - act.object_props.set_cc_link_vec::(vec![]).expect("NewComment::create_acitivity: cc error"); + act.create_props.set_actor_link(author.into_id()).expect("Comment::create_activity: actor error"); + act.create_props.set_object_object(note.clone()).expect("Comment::create_activity: object error"); + act.object_props.set_id_string(format!("{}/activity", self.ap_url.clone().expect("Comment::create_activity: ap_url error"))).expect("Comment::create_activity: id error"); + act.object_props.set_to_link_vec(note.object_props.to_link_vec::().expect("Comment::create_activity: id error")).expect("Comment::create_activity: to error"); + act.object_props.set_cc_link_vec::(vec![]).expect("Comment::create_activity: cc error"); act } } impl FromActivity for Comment { fn from_activity(conn: &Connection, note: Note, actor: Id) -> Comment { - let previous_url = note.object_props.in_reply_to.clone().unwrap().as_str().unwrap().to_string(); + let previous_url = note.object_props.in_reply_to.clone().expect("Comment::from_activity: not an answer error").as_str().expect("Comment::from_activity: in_reply_to parsing error").to_string(); let previous_comment = Comment::find_by_ap_url(conn, previous_url.clone()); let comm = Comment::insert(conn, NewComment { - content: SafeString::new(¬e.object_props.content_string().unwrap()), + content: SafeString::new(¬e.object_props.content_string().expect("Comment::from_activity: content deserialization error")), spoiler_text: note.object_props.summary_string().unwrap_or(String::from("")), ap_url: note.object_props.id_string().ok(), in_response_to_id: previous_comment.clone().map(|c| c.id), post_id: previous_comment .map(|c| c.post_id) - .unwrap_or_else(|| Post::find_by_ap_url(conn, previous_url).unwrap().id), - author_id: User::from_url(conn, actor.clone().into()).unwrap().id, + .unwrap_or_else(|| Post::find_by_ap_url(conn, previous_url).expect("Comment::from_activity: post error").id), + author_id: User::from_url(conn, actor.clone().into()).expect("Comment::from_activity: author error").id, sensitive: false // "sensitive" is not a standard property, we need to think about how to support it with the activitypub crate }); @@ -157,8 +157,8 @@ impl FromActivity for Comment { for tag in tags.into_iter() { serde_json::from_value::(tag) .map(|m| { - let author = &Post::get(conn, comm.post_id).unwrap().get_authors(conn)[0]; - let not_author = m.link_props.href_string().expect("Comment mention: no href") != author.ap_url.clone(); + let author = &Post::get(conn, comm.post_id).expect("Comment::from_activity: error").get_authors(conn)[0]; + let not_author = m.link_props.href_string().expect("Comment::from_activity: no href error") != author.ap_url.clone(); Mention::from_activity(conn, m, comm.id, false, not_author) }).ok(); } diff --git a/plume-models/src/follows.rs b/plume-models/src/follows.rs index 81606c02..145b3608 100644 --- a/plume-models/src/follows.rs +++ b/plume-models/src/follows.rs @@ -38,15 +38,15 @@ impl Follow { } pub fn into_activity(&self, conn: &Connection) -> FollowAct { - let user = User::get(conn, self.follower_id).unwrap(); - let target = User::get(conn, self.following_id).unwrap(); + let user = User::get(conn, self.follower_id).expect("Follow::into_activity: actor not found error"); + let target = User::get(conn, self.following_id).expect("Follow::into_activity: target not found error"); let mut act = FollowAct::default(); act.follow_props.set_actor_link::(user.clone().into_id()).expect("Follow::into_activity: actor error"); - act.follow_props.set_object_object(user.into_activity(&*conn)).unwrap(); - act.object_props.set_id_string(self.ap_url.clone()).unwrap(); - act.object_props.set_to_link(target.clone().into_id()).expect("New Follow error while setting 'to'"); - act.object_props.set_cc_link_vec::(vec![]).expect("New Follow error while setting 'cc'"); + act.follow_props.set_object_object(user.into_activity(&*conn)).expect("Follow::into_activity: object error"); + act.object_props.set_id_string(self.ap_url.clone()).expect("Follow::into_activity: id error"); + act.object_props.set_to_link(target.clone().into_id()).expect("Follow::into_activity: target error"); + act.object_props.set_cc_link_vec::(vec![]).expect("Follow::into_activity: cc error"); act } @@ -70,11 +70,11 @@ impl Follow { let mut accept = Accept::default(); let accept_id = format!("{}#accept", follow.object_props.id_string().unwrap_or(String::new())); - accept.object_props.set_id_string(accept_id).expect("accept_follow: id error"); - accept.object_props.set_to_link(from.clone().into_id()).expect("accept_follow: to error"); - accept.object_props.set_cc_link_vec::(vec![]).expect("accept_follow: cc error"); - accept.accept_props.set_actor_link::(target.clone().into_id()).unwrap(); - accept.accept_props.set_object_object(follow).unwrap(); + accept.object_props.set_id_string(accept_id).expect("Follow::accept_follow: id error"); + accept.object_props.set_to_link(from.clone().into_id()).expect("Follow::accept_follow: to error"); + accept.object_props.set_cc_link_vec::(vec![]).expect("Follow::accept_follow: cc error"); + accept.accept_props.set_actor_link::(target.clone().into_id()).expect("Follow::accept_follow: actor error"); + accept.accept_props.set_object_object(follow).expect("Follow::accept_follow: object error"); broadcast(&*target, accept, vec![from.clone()]); res } @@ -83,12 +83,13 @@ impl Follow { impl FromActivity for Follow { fn from_activity(conn: &Connection, follow: FollowAct, _actor: Id) -> Follow { let from_id = follow.follow_props.actor_link::().map(|l| l.into()) - .unwrap_or_else(|_| follow.follow_props.actor_object::().expect("No actor object (nor ID) on Follow").object_props.id_string().expect("No ID on actor on Follow")); - let from = User::from_url(conn, from_id).unwrap(); - match User::from_url(conn, follow.follow_props.object.as_str().unwrap().to_string()) { + .unwrap_or_else(|_| follow.follow_props.actor_object::().expect("Follow::from_activity: actor not found error").object_props.id_string().expect("Follow::from_activity: actor not found error")); + let from = User::from_url(conn, from_id).expect("Follow::from_activity: actor not found error"); + match User::from_url(conn, follow.follow_props.object.as_str().expect("Follow::from_activity: target url parsing error").to_string()) { Some(user) => Follow::accept_follow(conn, &from, &user, follow, from.id, user.id), None => { - let blog = Blog::from_url(conn, follow.follow_props.object.as_str().unwrap().to_string()).unwrap(); + let blog = Blog::from_url(conn, follow.follow_props.object.as_str().expect("Follow::from_activity: target url parsing error").to_string()) + .expect("Follow::from_activity: target not found error"); Follow::accept_follow(conn, &from, &blog, follow, from.id, blog.id) } } @@ -107,15 +108,15 @@ impl Notify for Follow { impl Deletable for Follow { fn delete(&self, conn: &Connection) -> Undo { - diesel::delete(self).execute(conn).expect("Coudn't delete follow"); + diesel::delete(self).execute(conn).expect("Follow::delete: follow deletion error"); // delete associated notification if any if let Some(notif) = Notification::find(conn, notification_kind::FOLLOW, self.id) { - diesel::delete(¬if).execute(conn).expect("Couldn't delete follow notification"); + diesel::delete(¬if).execute(conn).expect("Follow::delete: notification deletion error"); } let mut undo = Undo::default(); - undo.undo_props.set_actor_link(User::get(conn, self.follower_id).unwrap().into_id()).expect("Follow::delete: actor error"); + undo.undo_props.set_actor_link(User::get(conn, self.follower_id).expect("Follow::delete: actor error").into_id()).expect("Follow::delete: actor error"); undo.object_props.set_id_string(format!("{}/undo", self.ap_url)).expect("Follow::delete: id error"); undo.undo_props.set_object_object(self.into_activity(conn)).expect("Follow::delete: object error"); undo diff --git a/plume-models/src/instance.rs b/plume-models/src/instance.rs index ed072111..21c332e8 100644 --- a/plume-models/src/instance.rs +++ b/plume-models/src/instance.rs @@ -44,14 +44,14 @@ impl Instance { instances::table.filter(instances::local.eq(true)) .limit(1) .load::(conn) - .expect("Error loading local instance infos") + .expect("Instance::get_local: loading error") .into_iter().nth(0) } pub fn get_remotes(conn: &Connection) -> Vec { instances::table.filter(instances::local.eq(false)) .load::(conn) - .expect("Error loading remote instances infos") + .expect("Instance::get_remotes: loading error") } pub fn page(conn: &Connection, (min, max): (i32, i32)) -> Vec { @@ -59,11 +59,11 @@ impl Instance { .offset(min.into()) .limit((max - min).into()) .load::(conn) - .expect("Error loading a page of instances") + .expect("Instance::page: loading error") } pub fn local_id(conn: &Connection) -> i32 { - Instance::get_local(conn).unwrap().id + Instance::get_local(conn).expect("Instance::local_id: local instance not found error").id } insert!(instances, NewInstance); @@ -74,14 +74,14 @@ impl Instance { diesel::update(self) .set(instances::blocked.eq(!self.blocked)) .execute(conn) - .expect("Couldn't block/unblock instance"); + .expect("Instance::toggle_block: update error"); } /// id: AP object id pub fn is_blocked(conn: &Connection, id: String) -> bool { for block in instances::table.filter(instances::blocked.eq(true)) .get_results::(conn) - .expect("Error listing blocked instances") { + .expect("Instance::is_blocked: loading error") { if id.starts_with(format!("https://{}", block.public_domain).as_str()) { return true; } @@ -94,7 +94,7 @@ impl Instance { users::table.filter(users::instance_id.eq(self.id)) .filter(users::is_admin.eq(true)) .load::(conn) - .expect("Couldn't load admins") + .expect("Instance::has_admin: loading error") .len() > 0 } @@ -103,7 +103,7 @@ impl Instance { .filter(users::is_admin.eq(true)) .limit(1) .get_result::(conn) - .expect("Couldn't load admins") + .expect("Instance::main_admin: loading error") } pub fn compute_box(&self, prefix: &'static str, name: String, box_name: &'static str) -> String { @@ -128,10 +128,10 @@ impl Instance { instances::short_description_html.eq(sd), instances::long_description_html.eq(ld) )).execute(conn) - .expect("Couldn't update instance"); + .expect("Instance::update: update error"); } pub fn count(conn: &Connection) -> i64 { - instances::table.count().get_result(conn).expect("Couldn't count instances") + instances::table.count().get_result(conn).expect("Instance::count: counting error") } } diff --git a/plume-models/src/lib.rs b/plume-models/src/lib.rs index 22e3532d..f80b7bd8 100644 --- a/plume-models/src/lib.rs +++ b/plume-models/src/lib.rs @@ -53,7 +53,7 @@ macro_rules! find_by { $(.filter($table::$col.eq($col)))+ .limit(1) .load::(conn) - .expect("Error loading $table by $col") + .expect("macro::find_by: Error loading $table by $col") .into_iter().nth(0) } }; @@ -78,7 +78,7 @@ macro_rules! list_by { $table::table $(.filter($table::$col.eq($col)))+ .load::(conn) - .expect("Error loading $table by $col") + .expect("macro::list_by: Error loading $table by $col") } }; } @@ -101,7 +101,7 @@ macro_rules! get { $table::table.filter($table::id.eq(id)) .limit(1) .load::(conn) - .expect("Error loading $table by id") + .expect("macro::get: Error loading $table by id") .into_iter().nth(0) } }; @@ -127,7 +127,7 @@ macro_rules! insert { diesel::insert_into($table::table) .values(new) .execute(conn) - .expect("Error saving new $table"); + .expect("macro::insert: Error saving new $table"); Self::last(conn) } }; @@ -154,9 +154,9 @@ macro_rules! update { diesel::update(self) .set(self) .execute(conn) - .expect(concat!("Error updating ", stringify!($table))); + .expect(concat!("macro::update: Error updating ", stringify!($table))); Self::get(conn, self.id) - .expect(concat!(stringify!($table), " we just updated doesn't exist anymore???")) + .expect(concat!("macro::update: ", stringify!($table), " we just updated doesn't exist anymore???")) } }; } @@ -179,9 +179,9 @@ macro_rules! last { $table::table.order_by($table::id.desc()) .limit(1) .load::(conn) - .expect(concat!("Error getting last ", stringify!($table))) + .expect(concat!("macro::last: Error getting last ", stringify!($table))) .iter().next() - .expect(concat!("No last ", stringify!($table))) + .expect(concat!("macro::last: No last ", stringify!($table))) .clone() } }; diff --git a/plume-models/src/likes.rs b/plume-models/src/likes.rs index a7617b9e..ba586b39 100644 --- a/plume-models/src/likes.rs +++ b/plume-models/src/likes.rs @@ -42,17 +42,17 @@ impl Like { diesel::update(self) .set(likes::ap_url.eq(format!( "{}/like/{}", - User::get(conn, self.user_id).unwrap().ap_url, - Post::get(conn, self.post_id).unwrap().ap_url + User::get(conn, self.user_id).expect("Like::update_ap_url: user error").ap_url, + Post::get(conn, self.post_id).expect("Like::update_ap_url: post error").ap_url ))) - .execute(conn).expect("Couldn't update AP URL"); + .execute(conn).expect("Like::update_ap_url: update error"); } } pub fn into_activity(&self, conn: &Connection) -> activity::Like { let mut act = activity::Like::default(); - act.like_props.set_actor_link(User::get(conn, self.user_id).unwrap().into_id()).expect("Like::into_activity: actor error"); - act.like_props.set_object_link(Post::get(conn, self.post_id).unwrap().into_id()).expect("Like::into_activity: object error"); + act.like_props.set_actor_link(User::get(conn, self.user_id).expect("Like::into_activity: user error").into_id()).expect("Like::into_activity: actor error"); + act.like_props.set_object_link(Post::get(conn, self.post_id).expect("Like::into_activity: post error").into_id()).expect("Like::into_activity: object error"); act.object_props.set_to_link(Id::new(PUBLIC_VISIBILTY.to_string())).expect("Like::into_activity: to error"); act.object_props.set_cc_link_vec::(vec![]).expect("Like::into_activity: cc error"); act.object_props.set_id_string(self.ap_url.clone()).expect("Like::into_activity: id error"); @@ -63,11 +63,11 @@ impl Like { impl FromActivity for Like { fn from_activity(conn: &Connection, like: activity::Like, _actor: Id) -> Like { - let liker = User::from_url(conn, like.like_props.actor.as_str().unwrap().to_string()); - let post = Post::find_by_ap_url(conn, like.like_props.object.as_str().unwrap().to_string()); + let liker = User::from_url(conn, like.like_props.actor.as_str().expect("Like::from_activity: actor error").to_string()); + let post = Post::find_by_ap_url(conn, like.like_props.object.as_str().expect("Like::from_activity: object error").to_string()); let res = Like::insert(conn, NewLike { - post_id: post.unwrap().id, - user_id: liker.unwrap().id, + post_id: post.expect("Like::from_activity: post error").id, + user_id: liker.expect("Like::from_activity: user error").id, ap_url: like.object_props.id_string().unwrap_or(String::from("")) }); res.notify(conn); @@ -77,7 +77,7 @@ impl FromActivity for Like { impl Notify for Like { fn notify(&self, conn: &Connection) { - let post = Post::get(conn, self.post_id).unwrap(); + let post = Post::get(conn, self.post_id).expect("Like::notify: post error"); for author in post.get_authors(conn) { Notification::insert(conn, NewNotification { kind: notification_kind::LIKE.to_string(), @@ -90,15 +90,15 @@ impl Notify for Like { impl Deletable for Like { fn delete(&self, conn: &Connection) -> activity::Undo { - diesel::delete(self).execute(conn).unwrap(); + diesel::delete(self).execute(conn).expect("Like::delete: delete error"); // delete associated notification if any if let Some(notif) = Notification::find(conn, notification_kind::LIKE, self.id) { - diesel::delete(¬if).execute(conn).expect("Couldn't delete like notification"); + diesel::delete(¬if).execute(conn).expect("Like::delete: notification error"); } let mut act = activity::Undo::default(); - act.undo_props.set_actor_link(User::get(conn, self.user_id).unwrap().into_id()).expect("Like::delete: actor error"); + act.undo_props.set_actor_link(User::get(conn, self.user_id).expect("Like::delete: user error").into_id()).expect("Like::delete: actor error"); act.undo_props.set_object_object(self.into_activity(conn)).expect("Like::delete: object error"); act.object_props.set_id_string(format!("{}#delete", self.ap_url)).expect("Like::delete: id error"); act.object_props.set_to_link(Id::new(PUBLIC_VISIBILTY.to_string())).expect("Like::delete: to error"); diff --git a/plume-models/src/medias.rs b/plume-models/src/medias.rs index 01639b18..484ab532 100644 --- a/plume-models/src/medias.rs +++ b/plume-models/src/medias.rs @@ -36,9 +36,9 @@ impl Media { list_by!(medias, for_user, owner_id as i32); pub fn to_json(&self, conn: &Connection) -> serde_json::Value { - let mut json = serde_json::to_value(self).unwrap(); + let mut json = serde_json::to_value(self).expect("Media::to_json: serialization error"); let url = self.url(conn); - let (preview, html, md) = match self.file_path.rsplitn(2, '.').next().unwrap() { + let (preview, html, md) = match self.file_path.rsplitn(2, '.').next().expect("Media::to_json: extension error") { "png" | "jpg" | "jpeg" | "gif" | "svg" => ( format!("\"{}\"", url, self.alt_text, self.alt_text), format!("\"{}\"", url, self.alt_text, self.alt_text), @@ -67,13 +67,13 @@ impl Media { if self.is_remote { self.remote_url.clone().unwrap_or(String::new()) } else { - ap_url(format!("{}/static/{}", Instance::get_local(conn).unwrap().public_domain, self.file_path)) + ap_url(format!("{}/static/{}", Instance::get_local(conn).expect("Media::url: local instance not found error").public_domain, self.file_path)) } } pub fn delete(&self, conn: &Connection) { - fs::remove_file(self.file_path.as_str()).expect("Couldn't delete media from disk"); - diesel::delete(self).execute(conn).expect("Couldn't remove media from DB"); + fs::remove_file(self.file_path.as_str()).expect("Media::delete: file deletion error"); + diesel::delete(self).execute(conn).expect("Media::delete: database entry deletion error"); } pub fn save_remote(conn: &Connection, url: String) -> Media { @@ -92,6 +92,6 @@ impl Media { diesel::update(self) .set(medias::owner_id.eq(id)) .execute(conn) - .expect("Couldn't update Media.owner_id"); + .expect("Media::set_owner: owner update error"); } } diff --git a/plume-models/src/mentions.rs b/plume-models/src/mentions.rs index b7328b9c..dfd1c9fd 100644 --- a/plume-models/src/mentions.rs +++ b/plume-models/src/mentions.rs @@ -57,16 +57,16 @@ impl Mention { pub fn build_activity(conn: &Connection, ment: String) -> link::Mention { let user = User::find_by_fqn(conn, ment.clone()); let mut mention = link::Mention::default(); - mention.link_props.set_href_string(user.clone().map(|u| u.ap_url).unwrap_or(String::new())).expect("Error setting mention's href"); - mention.link_props.set_name_string(format!("@{}", ment)).expect("Error setting mention's name"); + mention.link_props.set_href_string(user.clone().map(|u| u.ap_url).unwrap_or(String::new())).expect("Mention::build_activity: href error"); + mention.link_props.set_name_string(format!("@{}", ment)).expect("Mention::build_activity: name error:"); mention } pub fn to_activity(&self, conn: &Connection) -> link::Mention { let user = self.get_mentioned(conn); let mut mention = link::Mention::default(); - mention.link_props.set_href_string(user.clone().map(|u| u.ap_url).unwrap_or(String::new())).expect("Error setting mention's href"); - mention.link_props.set_name_string(user.map(|u| format!("@{}", u.get_fqn(conn))).unwrap_or(String::new())).expect("Error setting mention's name"); + mention.link_props.set_href_string(user.clone().map(|u| u.ap_url).unwrap_or(String::new())).expect("Mention::to_activity: href error"); + mention.link_props.set_name_string(user.map(|u| format!("@{}", u.get_fqn(conn))).unwrap_or(String::new())).expect("Mention::to_activity: mention error"); mention } diff --git a/plume-models/src/notifications.rs b/plume-models/src/notifications.rs index 268096ff..881c899d 100644 --- a/plume-models/src/notifications.rs +++ b/plume-models/src/notifications.rs @@ -45,7 +45,7 @@ impl Notification { notifications::table.filter(notifications::user_id.eq(user.id)) .order_by(notifications::creation_date.desc()) .load::(conn) - .expect("Couldn't load user notifications") + .expect("Notification::find_for_user: notification loading error") } pub fn page_for_user(conn: &Connection, user: &User, (min, max): (i32, i32)) -> Vec { @@ -54,7 +54,7 @@ impl Notification { .offset(min.into()) .limit((max - min).into()) .load::(conn) - .expect("Couldn't load user notifications page") + .expect("Notification::page_for_user: notification loading error") } pub fn find>(conn: &Connection, kind: S, obj: i32) -> Option { @@ -90,9 +90,9 @@ impl Notification { "user": mention.get_user(conn).map(|u| u.to_json(conn)), "url": mention.get_post(conn).map(|p| p.to_json(conn)["url"].clone()) .unwrap_or_else(|| { - let comment = mention.get_comment(conn).expect("No comment nor post for mention"); + let comment = mention.get_comment(conn).expect("Notification::to_json: comment not found error"); let post = comment.get_post(conn).to_json(conn); - json!(format!("{}#comment-{}", post["url"].as_str().unwrap(), comment.id)) + json!(format!("{}#comment-{}", post["url"].as_str().expect("Notification::to_json: post url error"), comment.id)) }) }) ), diff --git a/plume-models/src/posts.rs b/plume-models/src/posts.rs index e4adf896..0c691008 100644 --- a/plume-models/src/posts.rs +++ b/plume-models/src/posts.rs @@ -122,7 +122,7 @@ impl Post { .offset(min.into()) .limit((max - min).into()) .load(conn) - .expect("Error loading posts by tag") + .expect("Post::list_by_tag: loading error") } pub fn count_for_tag(conn: &Connection, tag: String) -> i64 { @@ -132,8 +132,8 @@ impl Post { .filter(posts::published.eq(true)) .count() .load(conn) - .expect("Error counting posts by tag") - .iter().next().unwrap() + .expect("Post::count_for_tag: counting error") + .iter().next().expect("Post::count_for_tag: no result error") } pub fn count_local(conn: &Connection) -> usize { @@ -144,12 +144,15 @@ impl Post { posts::table.filter(posts::id.eq_any(local_posts_id)) .filter(posts::published.eq(true)) .load::(conn) - .expect("Couldn't load local posts") - .len() + .expect("Post::count_local: loading error") + .len()// TODO count in database? } pub fn count(conn: &Connection) -> i64 { - posts::table.filter(posts::published.eq(true)).count().get_result(conn).expect("Couldn't count posts") + posts::table.filter(posts::published.eq(true)) + .count() + .get_result(conn) + .expect("Post::count: counting error") } pub fn get_recents(conn: &Connection, limit: i64) -> Vec { @@ -157,7 +160,7 @@ impl Post { .filter(posts::published.eq(true)) .limit(limit) .load::(conn) - .expect("Error loading recent posts") + .expect("Post::get_recents: loading error") } pub fn get_recents_for_author(conn: &Connection, author: &User, limit: i64) -> Vec { @@ -169,7 +172,7 @@ impl Post { .order(posts::creation_date.desc()) .limit(limit) .load::(conn) - .expect("Error loading recent posts for author") + .expect("Post::get_recents_for_author: loading error") } pub fn get_recents_for_blog(conn: &Connection, blog: &Blog, limit: i64) -> Vec { @@ -178,14 +181,14 @@ impl Post { .order(posts::creation_date.desc()) .limit(limit) .load::(conn) - .expect("Error loading recent posts for blog") + .expect("Post::get_recents_for_blog: loading error") } pub fn get_for_blog(conn: &Connection, blog:&Blog) -> Vec { posts::table.filter(posts::blog_id.eq(blog.id)) .filter(posts::published.eq(true)) .load::(conn) - .expect("Error loading posts for blog") + .expect("Post::get_for_blog:: loading error") } pub fn blog_page(conn: &Connection, blog: &Blog, (min, max): (i32, i32)) -> Vec { @@ -195,7 +198,7 @@ impl Post { .offset(min.into()) .limit((max - min).into()) .load::(conn) - .expect("Error loading a page of posts for blog") + .expect("Post::blog_page: loading error") } /// Give a page of all the recent posts known to this instance (= federated timeline) @@ -205,7 +208,7 @@ impl Post { .offset(min.into()) .limit((max - min).into()) .load::(conn) - .expect("Error loading recent posts page") + .expect("Post::get_recents_page: loading error") } /// Give a page of posts from a specific instance @@ -220,7 +223,7 @@ impl Post { .offset(min.into()) .limit((max - min).into()) .load::(conn) - .expect("Error loading local posts page") + .expect("Post::get_instance_page: loading error") } /// Give a page of customized user feed, based on a list of followed users @@ -236,7 +239,7 @@ impl Post { .offset(min.into()) .limit((max - min).into()) .load::(conn) - .expect("Error loading user feed page") + .expect("Post::user_feed_page: loading error") } pub fn drafts_by_author(conn: &Connection, author: &User) -> Vec { @@ -247,14 +250,14 @@ impl Post { .filter(posts::published.eq(false)) .filter(posts::id.eq_any(posts)) .load::(conn) - .expect("Error listing drafts") + .expect("Post::drafts_by_author: loading error") } pub fn get_authors(&self, conn: &Connection) -> Vec { use schema::users; use schema::post_authors; let author_list = PostAuthor::belonging_to(self).select(post_authors::author_id); - users::table.filter(users::id.eq_any(author_list)).load::(conn).unwrap() + users::table.filter(users::id.eq_any(author_list)).load::(conn).expect("Post::get_authors: loading error") } pub fn get_blog(&self, conn: &Connection) -> Blog { @@ -262,30 +265,30 @@ impl Post { blogs::table.filter(blogs::id.eq(self.blog_id)) .limit(1) .load::(conn) - .expect("Couldn't load blog associted to post") - .into_iter().nth(0).unwrap() + .expect("Post::get_blog: loading error") + .into_iter().nth(0).expect("Post::get_blog: no result error") } pub fn get_likes(&self, conn: &Connection) -> Vec { use schema::likes; likes::table.filter(likes::post_id.eq(self.id)) .load::(conn) - .expect("Couldn't load likes associted to post") + .expect("Post::get_likes: loading error") } pub fn get_reshares(&self, conn: &Connection) -> Vec { use schema::reshares; reshares::table.filter(reshares::post_id.eq(self.id)) .load::(conn) - .expect("Couldn't load reshares associted to post") + .expect("Post::get_reshares: loading error") } pub fn update_ap_url(&self, conn: &Connection) -> Post { if self.ap_url.len() == 0 { diesel::update(self) .set(posts::ap_url.eq(self.compute_id(conn))) - .execute(conn).expect("Couldn't update AP URL"); - Post::get(conn, self.id).unwrap() + .execute(conn).expect("Post::update_ap_url: update error"); + Post::get(conn, self.id).expect("Post::update_ap_url: get error") } else { self.clone() } @@ -359,7 +362,7 @@ impl Post { pub fn handle_update(conn: &Connection, updated: Article) { let id = updated.object_props.id_string().expect("Post::handle_update: id error"); - let mut post = Post::find_by_ap_url(conn, id).unwrap(); + let mut post = Post::find_by_ap_url(conn, id).expect("Post::handle_update: finding error"); if let Ok(title) = updated.object_props.name_string() { post.slug = title.to_kebab_case(); @@ -423,7 +426,7 @@ impl FromActivity for Post { let title = article.object_props.name_string().expect("Post::from_activity: title error"); let post = Post::insert(conn, NewPost { - blog_id: blog.expect("Received a new Article without a blog").id, + blog_id: blog.expect("Post::from_activity: blog not found error").id, slug: title.to_kebab_case(), title: title, content: SafeString::new(&article.object_props.content_string().expect("Post::from_activity: content error")), diff --git a/plume-models/src/reshares.rs b/plume-models/src/reshares.rs index db04bcc9..6d4ec372 100644 --- a/plume-models/src/reshares.rs +++ b/plume-models/src/reshares.rs @@ -37,10 +37,10 @@ impl Reshare { diesel::update(self) .set(reshares::ap_url.eq(format!( "{}/reshare/{}", - User::get(conn, self.user_id).unwrap().ap_url, - Post::get(conn, self.post_id).unwrap().ap_url + User::get(conn, self.user_id).expect("Reshare::update_ap_url: user error").ap_url, + Post::get(conn, self.post_id).expect("Reshare::update_ap_url: post error").ap_url ))) - .execute(conn).expect("Couldn't update AP URL"); + .execute(conn).expect("Reshare::update_ap_url: update error"); } } @@ -49,7 +49,7 @@ impl Reshare { .order(reshares::creation_date.desc()) .limit(limit) .load::(conn) - .expect("Error loading recent reshares for user") + .expect("Reshare::get_recents_for_author: loading error") } pub fn get_post(&self, conn: &Connection) -> Option { @@ -62,9 +62,11 @@ impl Reshare { pub fn into_activity(&self, conn: &Connection) -> Announce { let mut act = Announce::default(); - act.announce_props.set_actor_link(User::get(conn, self.user_id).unwrap().into_id()).unwrap(); - act.announce_props.set_object_link(Post::get(conn, self.post_id).unwrap().into_id()).unwrap(); - act.object_props.set_id_string(self.ap_url.clone()).unwrap(); + act.announce_props.set_actor_link(User::get(conn, self.user_id).expect("Reshare::into_activity: user error").into_id()) + .expect("Reshare::into_activity: actor error"); + act.announce_props.set_object_link(Post::get(conn, self.post_id).expect("Reshare::into_activity: post error").into_id()) + .expect("Reshare::into_activity: object error"); + act.object_props.set_id_string(self.ap_url.clone()).expect("Reshare::into_activity: id error"); act.object_props.set_to_link(Id::new(PUBLIC_VISIBILTY.to_string())).expect("Reshare::into_activity: to error"); act.object_props.set_cc_link_vec::(vec![]).expect("Reshare::into_activity: cc error"); @@ -77,8 +79,8 @@ impl FromActivity for Reshare { let user = User::from_url(conn, announce.announce_props.actor_link::().expect("Reshare::from_activity: actor error").into()); let post = Post::find_by_ap_url(conn, announce.announce_props.object_link::().expect("Reshare::from_activity: object error").into()); let reshare = Reshare::insert(conn, NewReshare { - post_id: post.unwrap().id, - user_id: user.unwrap().id, + post_id: post.expect("Reshare::from_activity: post error").id, + user_id: user.expect("Reshare::from_activity: user error").id, ap_url: announce.object_props.id_string().unwrap_or(String::from("")) }); reshare.notify(conn); @@ -88,7 +90,7 @@ impl FromActivity for Reshare { impl Notify for Reshare { fn notify(&self, conn: &Connection) { - let post = self.get_post(conn).unwrap(); + let post = self.get_post(conn).expect("Reshare::notify: post error"); for author in post.get_authors(conn) { Notification::insert(conn, NewNotification { kind: notification_kind::RESHARE.to_string(), @@ -101,16 +103,16 @@ impl Notify for Reshare { impl Deletable for Reshare { fn delete(&self, conn: &Connection) -> Undo { - diesel::delete(self).execute(conn).unwrap(); + diesel::delete(self).execute(conn).expect("Reshare::delete: delete error"); // delete associated notification if any if let Some(notif) = Notification::find(conn, notification_kind::RESHARE, self.id) { - diesel::delete(¬if).execute(conn).expect("Couldn't delete reshare notification"); + diesel::delete(¬if).execute(conn).expect("Reshare::delete: notification error"); } let mut act = Undo::default(); - act.undo_props.set_actor_link(User::get(conn, self.user_id).unwrap().into_id()).unwrap(); - act.undo_props.set_object_object(self.into_activity(conn)).unwrap(); + act.undo_props.set_actor_link(User::get(conn, self.user_id).expect("Reshare::delete: user error").into_id()).expect("Reshare::delete: actor error"); + act.undo_props.set_object_object(self.into_activity(conn)).expect("Reshare::delete: object error"); act.object_props.set_id_string(format!("{}#delete", self.ap_url)).expect("Reshare::delete: id error"); act.object_props.set_to_link(Id::new(PUBLIC_VISIBILTY.to_string())).expect("Reshare::delete: to error"); act.object_props.set_cc_link_vec::(vec![]).expect("Reshare::delete: cc error"); diff --git a/plume-models/src/tags.rs b/plume-models/src/tags.rs index d906601f..fa961136 100644 --- a/plume-models/src/tags.rs +++ b/plume-models/src/tags.rs @@ -29,7 +29,10 @@ impl Tag { pub fn into_activity(&self, conn: &Connection) -> Hashtag { let mut ht = Hashtag::default(); - ht.set_href_string(ap_url(format!("{}/tag/{}", Instance::get_local(conn).unwrap().public_domain, self.tag))).expect("Tag::into_activity: href error"); + ht.set_href_string(ap_url(format!("{}/tag/{}", + Instance::get_local(conn).expect("Tag::into_activity: local instance not found error").public_domain, + self.tag) + )).expect("Tag::into_activity: href error"); ht.set_name_string(self.tag.clone()).expect("Tag::into_activity: name error"); ht } diff --git a/plume-models/src/users.rs b/plume-models/src/users.rs index e5b62562..35afb73f 100644 --- a/plume-models/src/users.rs +++ b/plume-models/src/users.rs @@ -102,7 +102,7 @@ impl User { pub fn one_by_instance(conn: &Connection) -> Vec { users::table.filter(users::instance_id.eq_any(users::table.select(users::instance_id).distinct())) .load::(conn) - .expect("Error in User::on_by_instance") + .expect("User::one_by_instance: loading error") } pub fn delete(&self, conn: &Connection) { @@ -113,31 +113,31 @@ impl User { .filter(post_authors::author_id.eq(self.id)) .select(post_authors::post_id) .load(conn) - .expect("Couldn't load posts IDs"); + .expect("User::delete: post loading error"); for post_id in all_their_posts_ids { let has_other_authors = post_authors::table .filter(post_authors::post_id.eq(post_id)) .filter(post_authors::author_id.ne(self.id)) .count() .load(conn) - .expect("Couldn't count other authors").iter().next().unwrap_or(&0) > &0; + .expect("User::delete: count author error").iter().next().unwrap_or(&0) > &0; if !has_other_authors { - Post::get(conn, post_id).expect("Post is already gone").delete(conn); + Post::get(conn, post_id).expect("User::delete: post not found error").delete(conn); } } - diesel::delete(self).execute(conn).expect("Couldn't remove user from DB"); + diesel::delete(self).execute(conn).expect("User::delete: user deletion error"); } pub fn get_instance(&self, conn: &Connection) -> Instance { - Instance::get(conn, self.instance_id).expect("Couldn't find instance") + Instance::get(conn, self.instance_id).expect("User::get_instance: instance not found error") } pub fn grant_admin_rights(&self, conn: &Connection) { diesel::update(self) .set(users::is_admin.eq(true)) .execute(conn) - .expect("Couldn't grant admin rights"); + .expect("User::grand_admin_rights: update error"); } pub fn update(&self, conn: &Connection, name: String, email: String, summary: String) -> User { @@ -147,15 +147,15 @@ impl User { users::email.eq(email), users::summary.eq(summary), )).execute(conn) - .expect("Couldn't update user"); - User::get(conn, self.id).unwrap() + .expect("User::update: update error"); + User::get(conn, self.id).expect("User::update: get error") } pub fn count_local(conn: &Connection) -> usize { users::table.filter(users::instance_id.eq(Instance::local_id(conn))) .load::(conn) - .expect("Couldn't load local users") - .len() + .expect("User::count_local: loading error") + .len()// TODO count in database? } pub fn find_local(conn: &Connection, username: String) -> Option { @@ -164,9 +164,9 @@ impl User { pub fn find_by_fqn(conn: &Connection, fqn: String) -> Option { if fqn.contains("@") { // remote user - match Instance::find_by_domain(conn, String::from(fqn.split("@").last().unwrap())) { + match Instance::find_by_domain(conn, String::from(fqn.split("@").last().expect("User::find_by_fqn: host error"))) { Some(instance) => { - match User::find_by_name(conn, String::from(fqn.split("@").nth(0).unwrap()), instance.id) { + match User::find_by_name(conn, String::from(fqn.split("@").nth(0).expect("User::find_by_fqn: name error")), instance.id) { Some(u) => Some(u), None => User::fetch_from_webfinger(conn, fqn) } @@ -180,7 +180,7 @@ impl User { fn fetch_from_webfinger(conn: &Connection, acct: String) -> Option { match resolve(acct.clone(), *USE_HTTPS) { - Ok(wf) => wf.links.into_iter().find(|l| l.mime_type == Some(String::from("application/activity+json"))).and_then(|l| User::fetch_from_url(conn, l.href.expect("No href for AP WF link"))), + Ok(wf) => wf.links.into_iter().find(|l| l.mime_type == Some(String::from("application/activity+json"))).and_then(|l| User::fetch_from_url(conn, l.href.expect("User::fetch_from_webginfer: href not found error"))), Err(details) => { println!("WF Error: {:?}", details); None @@ -191,7 +191,7 @@ impl User { fn fetch(url: String) -> Option { let req = Client::new() .get(&url[..]) - .header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::>().join(", ")).unwrap()) + .header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::>().join(", ")).expect("User::fetch: accept header error")) .send(); match req { Ok(mut res) => { @@ -212,7 +212,9 @@ impl User { } pub fn fetch_from_url(conn: &Connection, url: String) -> Option { - User::fetch(url.clone()).map(|json| (User::from_activity(conn, json, Url::parse(url.as_ref()).unwrap().host_str().unwrap().to_string()))) + User::fetch(url.clone()).map(|json| (User::from_activity(conn, json, Url::parse(url.as_ref()) + .expect("User::fetch_from_url: url error").host_str() + .expect("User::fetch_from_url: host error").to_string()))) } fn from_activity(conn: &Connection, acct: CustomPerson, inst: String) -> User { @@ -277,16 +279,16 @@ impl User { users::avatar_id.eq(Some(avatar.id)), users::last_fetched_date.eq(Utc::now().naive_utc()) )).execute(conn) - .expect("Couldn't update user") + .expect("User::refetch: update error") }); } pub fn hash_pass(pass: String) -> String { - bcrypt::hash(pass.as_str(), 10).unwrap() + bcrypt::hash(pass.as_str(), 10).expect("User::hash_pass: hashing error") } pub fn auth(&self, pass: String) -> bool { - if let Ok(valid) = bcrypt::verify(pass.as_str(), self.hashed_password.clone().unwrap().as_str()) { + if let Ok(valid) = bcrypt::verify(pass.as_str(), self.hashed_password.clone().expect("User::auth: no password error").as_str()) { valid } else { false @@ -298,31 +300,31 @@ impl User { if self.outbox_url.len() == 0 { diesel::update(self) .set(users::outbox_url.eq(instance.compute_box(USER_PREFIX, self.username.clone(), "outbox"))) - .execute(conn).expect("Couldn't update outbox URL"); + .execute(conn).expect("User::update_boxes: outbox update error"); } if self.inbox_url.len() == 0 { diesel::update(self) .set(users::inbox_url.eq(instance.compute_box(USER_PREFIX, self.username.clone(), "inbox"))) - .execute(conn).expect("Couldn't update inbox URL"); + .execute(conn).expect("User::update_boxes: inbox update error"); } if self.ap_url.len() == 0 { diesel::update(self) .set(users::ap_url.eq(instance.compute_box(USER_PREFIX, self.username.clone(), ""))) - .execute(conn).expect("Couldn't update AP URL"); + .execute(conn).expect("User::update_boxes: ap_url update error"); } if self.shared_inbox_url.is_none() { diesel::update(self) - .set(users::shared_inbox_url.eq(ap_url(format!("{}/inbox", Instance::get_local(conn).unwrap().public_domain)))) - .execute(conn).expect("Couldn't update shared inbox URL"); + .set(users::shared_inbox_url.eq(ap_url(format!("{}/inbox", Instance::get_local(conn).expect("User::update_boxes: local instance not found error").public_domain)))) + .execute(conn).expect("User::update_boxes: shared inbox update error"); } if self.followers_endpoint.len() == 0 { diesel::update(self) .set(users::followers_endpoint.eq(instance.compute_box(USER_PREFIX, self.username.clone(), "followers"))) - .execute(conn).expect("Couldn't update followers endpoint"); + .execute(conn).expect("User::update_boxes: follower update error"); } } @@ -332,27 +334,27 @@ impl User { .offset(min.into()) .limit((max - min).into()) .load::(conn) - .expect("Error getting local users page") + .expect("User::get_local_page: loading error") } pub fn outbox(&self, conn: &Connection) -> ActivityStream { let acts = self.get_activities(conn); let n_acts = acts.len(); let mut coll = OrderedCollection::default(); - coll.collection_props.items = serde_json::to_value(acts).unwrap(); - coll.collection_props.set_total_items_u64(n_acts as u64).unwrap(); + coll.collection_props.items = serde_json::to_value(acts).expect("User::outbox: activity error"); + coll.collection_props.set_total_items_u64(n_acts as u64).expect("User::outbox: count error"); ActivityStream::new(coll) } pub fn fetch_outbox(&self) -> Vec { let req = Client::new() .get(&self.outbox_url[..]) - .header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::>().join(", ")).unwrap()) + .header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::>().join(", ")).expect("User::fetch_outbox: accept header error")) .send(); match req { Ok(mut res) => { - let text = &res.text().unwrap(); - let json: serde_json::Value = serde_json::from_str(text).unwrap(); + let text = &res.text().expect("User::fetch_outbox: body error"); + let json: serde_json::Value = serde_json::from_str(text).expect("User::fetch_outbox: parsing error"); json["items"].as_array() .expect("Outbox.items is not an array") .into_iter() @@ -369,14 +371,14 @@ impl User { pub fn fetch_followers_ids(&self) -> Vec { let req = Client::new() .get(&self.followers_endpoint[..]) - .header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::>().join(", ")).unwrap()) + .header(ACCEPT, HeaderValue::from_str(&ap_accept_header().into_iter().collect::>().join(", ")).expect("User::fetch_followers_ids: accept header error")) .send(); match req { Ok(mut res) => { - let text = &res.text().unwrap(); - let json: serde_json::Value = serde_json::from_str(text).unwrap(); + let text = &res.text().expect("User::fetch_followers_ids: body error"); + let json: serde_json::Value = serde_json::from_str(text).expect("User::fetch_followers_ids: parsing error"); json["items"].as_array() - .expect("Followers.items is not an array") + .expect("User::fetch_followers_ids: not an array error") .into_iter() .filter_map(|j| serde_json::from_value(j.clone()).ok()) .collect::>() @@ -395,9 +397,9 @@ impl User { let posts = posts::table .filter(posts::published.eq(true)) .filter(posts::id.eq_any(posts_by_self)) - .load::(conn).unwrap(); + .load::(conn).expect("User::get_activities: loading error"); posts.into_iter().map(|p| { - serde_json::to_value(p.create_activity(conn)).unwrap() + serde_json::to_value(p.create_activity(conn)).expect("User::get_activities: creation error") }).collect::>() } @@ -412,7 +414,7 @@ impl User { pub fn get_followers(&self, conn: &Connection) -> Vec { use schema::follows; let follows = Follow::belonging_to(self).select(follows::follower_id); - users::table.filter(users::id.eq_any(follows)).load::(conn).unwrap() + users::table.filter(users::id.eq_any(follows)).load::(conn).expect("User::get_followers: loading error") } pub fn get_followers_page(&self, conn: &Connection, (min, max): (i32, i32)) -> Vec { @@ -421,13 +423,13 @@ impl User { users::table.filter(users::id.eq_any(follows)) .offset(min.into()) .limit((max - min).into()) - .load::(conn).unwrap() + .load::(conn).expect("User::get_followers_page: loading error") } pub fn get_following(&self, conn: &Connection) -> Vec { use schema::follows::dsl::*; let f = follows.filter(follower_id.eq(self.id)).select(following_id); - users::table.filter(users::id.eq_any(f)).load::(conn).unwrap() + users::table.filter(users::id.eq_any(f)).load::(conn).expect("User::get_following: loading error") } pub fn is_followed_by(&self, conn: &Connection, other_id: i32) -> bool { @@ -436,8 +438,8 @@ impl User { .filter(follows::follower_id.eq(other_id)) .filter(follows::following_id.eq(self.id)) .load::(conn) - .expect("Couldn't load follow relationship") - .len() > 0 + .expect("User::is_followed_by: loading error") + .len() > 0// TODO count in database? } pub fn is_following(&self, conn: &Connection, other_id: i32) -> bool { @@ -446,8 +448,8 @@ impl User { .filter(follows::follower_id.eq(self.id)) .filter(follows::following_id.eq(other_id)) .load::(conn) - .expect("Couldn't load follow relationship") - .len() > 0 + .expect("User::is_following: loading error") + .len() > 0// TODO count in database? } pub fn has_liked(&self, conn: &Connection, post: &Post) -> bool { @@ -456,8 +458,8 @@ impl User { .filter(likes::post_id.eq(post.id)) .filter(likes::user_id.eq(self.id)) .load::(conn) - .expect("Couldn't load likes") - .len() > 0 + .expect("User::has_liked: loading error") + .len() > 0// TODO count in database? } pub fn has_reshared(&self, conn: &Connection, post: &Post) -> bool { @@ -466,8 +468,8 @@ impl User { .filter(reshares::post_id.eq(post.id)) .filter(reshares::user_id.eq(self.id)) .load::(conn) - .expect("Couldn't load reshares") - .len() > 0 + .expect("User::has_reshared: loading error") + .len() > 0// TODO count in database? } pub fn is_author_in(&self, conn: &Connection, blog: Blog) -> bool { @@ -475,12 +477,14 @@ impl User { blog_authors::table.filter(blog_authors::author_id.eq(self.id)) .filter(blog_authors::blog_id.eq(blog.id)) .load::(conn) - .expect("Couldn't load blog/author relationship") - .len() > 0 + .expect("User::is_author_in: loading error") + .len() > 0// TODO count in database? } pub fn get_keypair(&self) -> PKey { - PKey::from_rsa(Rsa::private_key_from_pem(self.private_key.clone().unwrap().as_ref()).unwrap()).unwrap() + PKey::from_rsa(Rsa::private_key_from_pem(self.private_key.clone().expect("User::get_keypair: private key not found error").as_ref()) + .expect("User::get_keypair: pem parsing error")) + .expect("User::get_keypair: private key deserialization error") } pub fn into_activity(&self, conn: &Connection) -> CustomPerson { @@ -514,7 +518,7 @@ impl User { } pub fn to_json(&self, conn: &Connection) -> serde_json::Value { - let mut json = serde_json::to_value(self).unwrap(); + let mut json = serde_json::to_value(self).expect("User::to_json: serializing error"); json["fqn"] = serde_json::Value::String(self.get_fqn(conn)); json["name"] = if self.display_name.len() > 0 { json!(self.display_name) @@ -556,7 +560,7 @@ impl User { User::find_by_ap_url(conn, url.clone()).or_else(|| { // The requested user was not in the DB // We try to fetch it if it is remote - if Url::parse(url.as_ref()).unwrap().host_str().unwrap() != BASE_URL.as_str() { + if Url::parse(url.as_ref()).expect("User::from_url: url error").host_str().expect("User::from_url: host error") != BASE_URL.as_str() { User::fetch_from_url(conn, url) } else { None @@ -568,7 +572,7 @@ impl User { diesel::update(self) .set(users::avatar_id.eq(id)) .execute(conn) - .expect("Couldn't update user avatar"); + .expect("User::set_avatar: update error"); } pub fn needs_update(&self) -> bool { @@ -584,7 +588,7 @@ impl<'a, 'r> FromRequest<'a, 'r> for User { request.cookies() .get_private(AUTH_COOKIE) .and_then(|cookie| cookie.value().parse().ok()) - .map(|id| User::get(&*conn, id).unwrap()) + .map(|id| User::get(&*conn, id).expect("User::from_request: user not found error")) .or_forward(()) } } @@ -619,16 +623,17 @@ impl Signer for User { fn sign(&self, to_sign: String) -> Vec { let key = self.get_keypair(); - let mut signer = sign::Signer::new(MessageDigest::sha256(), &key).unwrap(); - signer.update(to_sign.as_bytes()).unwrap(); - signer.sign_to_vec().unwrap() + let mut signer = sign::Signer::new(MessageDigest::sha256(), &key).expect("User::sign: initialization error"); + signer.update(to_sign.as_bytes()).expect("User::sign: content insertion error"); + signer.sign_to_vec().expect("User::sign: finalization error") } fn verify(&self, data: String, signature: Vec) -> bool { - let key = PKey::from_rsa(Rsa::public_key_from_pem(self.public_key.as_ref()).unwrap()).unwrap(); - let mut verifier = sign::Verifier::new(MessageDigest::sha256(), &key).unwrap(); - verifier.update(data.as_bytes()).unwrap(); - verifier.verify(&signature).unwrap() + let key = PKey::from_rsa(Rsa::public_key_from_pem(self.public_key.as_ref()).expect("User::verify: pem parsing error")) + .expect("User::verify: deserialization error"); + let mut verifier = sign::Verifier::new(MessageDigest::sha256(), &key).expect("User::verify: initialization error"); + verifier.update(data.as_bytes()).expect("User::verify: content insertion error"); + verifier.verify(&signature).expect("User::verify: finalization error") } } @@ -655,8 +660,8 @@ impl NewUser { hashed_password: Some(password), instance_id: Instance::local_id(conn), ap_url: String::from(""), - public_key: String::from_utf8(pub_key).unwrap(), - private_key: Some(String::from_utf8(priv_key).unwrap()), + public_key: String::from_utf8(pub_key).expect("NewUser::new_local: public key error"), + private_key: Some(String::from_utf8(priv_key).expect("NewUser::new_local: private key error")), shared_inbox_url: None, followers_endpoint: String::from(""), avatar_id: None