kotovalexarian-likes-gitlab
/
hagrid-keyserver--hagrid
mirror of https://gitlab.com/hagrid-keyserver/hagrid.git
1
0
Fork 0
Code Releases Activity

web: rename request_origin -> origin, it is a mouthful already

This commit is contained in:
Justus Winter 2022-01-17 16:03:56 +01:00 committed by Vincent Breitmoser
parent cf0abbe047
commit b97a06f51c
5 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/web/hkp.rs
View File

@ -133,7 +133,7 @@ pub async fn pks_add_form_data(
#[post("/pks/add", format = "application/x-www-form-urlencoded", data = "<data>")]
pub async fn pks_add_form(
request_origin: RequestOrigin,
origin: RequestOrigin,
db: &rocket::State<KeyDatabase>,
tokens_stateless: &rocket::State<tokens::Service>,
rate_limiter: &rocket::State<RateLimiter>,
@ -143,11 +143,11 @@ pub async fn pks_add_form(
) -> MyResponse {
match vks_web::process_post_form(&db, &tokens_stateless, &rate_limiter, &i18n, data).await {
Ok(UploadResponse::Ok { is_new_key, key_fpr, primary_uid, token, status, .. }) => {
let msg = pks_add_ok(&request_origin, &mail_service, &rate_limiter, token, status, is_new_key, key_fpr, primary_uid);
let msg = pks_add_ok(&origin, &mail_service, &rate_limiter, token, status, is_new_key, key_fpr, primary_uid);
MyResponse::plain(msg)
}
Ok(_) => {
let msg = format!("Upload successful. Please note that identity information will only be published after verification. See {baseuri}/about/usage#gnupg-upload", baseuri = request_origin.get_base_uri());
let msg = format!("Upload successful. Please note that identity information will only be published after verification. See {baseuri}/about/usage#gnupg-upload", baseuri = origin.get_base_uri());
MyResponse::plain(msg)
}
Err(err) => MyResponse::ise(err),
@ -155,7 +155,7 @@ pub async fn pks_add_form(
}
fn pks_add_ok(
request_origin: &RequestOrigin,
origin: &RequestOrigin,
mail_service: &mail::Service,
rate_limiter: &RateLimiter,
token: String,
@ -165,16 +165,16 @@ fn pks_add_ok(
primary_uid: Option<Email>,
) -> String {
if primary_uid.is_none() {
return format!("Upload successful. Please note that identity information will only be published after verification. See {baseuri}/about/usage#gnupg-upload", baseuri = request_origin.get_base_uri())
return format!("Upload successful. Please note that identity information will only be published after verification. See {baseuri}/about/usage#gnupg-upload", baseuri = origin.get_base_uri())
}
let primary_uid = primary_uid.unwrap();
if is_new_key {
if send_welcome_mail(&request_origin, &mail_service, key_fpr, &primary_uid, token) {
if send_welcome_mail(&origin, &mail_service, key_fpr, &primary_uid, token) {
rate_limiter.action_perform(format!("hkp-sent-{}", &primary_uid));
return format!("Upload successful. This is a new key, a welcome email has been sent.");
}
return format!("Upload successful. Please note that identity information will only be published after verification. See {baseuri}/about/usage#gnupg-upload", baseuri = request_origin.get_base_uri())
return format!("Upload successful. Please note that identity information will only be published after verification. See {baseuri}/about/usage#gnupg-upload", baseuri = origin.get_base_uri())
}
let has_unverified = status.iter().any(|(_, v)| *v == EmailStatus::Unpublished);
@ -182,17 +182,17 @@ fn pks_add_ok(
return format!("Upload successful.");
}
return format!("Upload successful. Please note that identity information will only be published after verification. See {baseuri}/about/usage#gnupg-upload", baseuri = request_origin.get_base_uri())
return format!("Upload successful. Please note that identity information will only be published after verification. See {baseuri}/about/usage#gnupg-upload", baseuri = origin.get_base_uri())
}
fn send_welcome_mail(
request_origin: &RequestOrigin,
origin: &RequestOrigin,
mail_service: &mail::Service,
fpr: String,
primary_uid: &Email,
token: String,
) -> bool {
mail_service.send_welcome(request_origin.get_base_uri(), fpr, primary_uid, &token).is_ok()
mail_service.send_welcome(origin.get_base_uri(), fpr, primary_uid, &token).is_ok()
}
#[get("/pks/lookup")]

30
src/web/manage.rs
View File

@ -63,7 +63,7 @@ pub fn vks_manage(origin: RequestOrigin, i18n: I18n) -> MyResponse {
#[get("/manage/<token>")]
pub fn vks_manage_key(
request_origin: RequestOrigin,
origin: RequestOrigin,
db: &rocket::State<KeyDatabase>,
i18n: I18n,
token: String,
@ -93,14 +93,14 @@ pub fn vks_manage_key(
key_link,
uid_status,
token,
base_uri: request_origin.get_base_uri().to_owned(),
base_uri: origin.get_base_uri().to_owned(),
};
MyResponse::ok("manage/manage_key", context, i18n, request_origin)
MyResponse::ok("manage/manage_key", context, i18n, origin)
},
Ok(None) => MyResponse::not_found(
Some("manage/manage"),
Some(i18n!(i18n.catalog, "This link is invalid or expired")),
i18n, request_origin,
i18n, origin,
),
Err(e) => MyResponse::ise(e),
}
@ -108,14 +108,14 @@ pub fn vks_manage_key(
MyResponse::not_found(
Some("manage/manage"),
Some(i18n!(i18n.catalog, "This link is invalid or expired")),
i18n, request_origin)
i18n, origin)
}
}
#[post("/manage", data="<request>")]
pub fn vks_manage_post(
db: &rocket::State<KeyDatabase>,
request_origin: RequestOrigin,
origin: RequestOrigin,
mail_service: &rocket::State<mail::Service>,
rate_limiter: &rocket::State<RateLimiter>,
i18n: I18n,
@ -129,7 +129,7 @@ pub fn vks_manage_post(
Err(_) => return MyResponse::not_found(
Some("manage/manage"),
Some(i18n!(i18n.catalog, "Malformed address: {}"; &request.search_term)),
i18n, request_origin)
i18n, origin)
};
let tpk = match db.lookup(&database::Query::ByEmail(email.clone())) {
@ -137,7 +137,7 @@ pub fn vks_manage_post(
Ok(None) => return MyResponse::not_found(
Some("manage/manage"),
Some(i18n!(i18n.catalog, "No key for address: {}"; &request.search_term)),
i18n, request_origin),
i18n, origin),
Err(e) => return MyResponse::ise(e),
};
@ -154,7 +154,7 @@ pub fn vks_manage_post(
return MyResponse::not_found(
Some("manage/manage"),
Some(i18n!(i18n.catalog, "A request has already been sent for this address recently.")),
i18n, request_origin);
i18n, origin);
}
let fpr: Fingerprint = tpk.fingerprint().try_into().unwrap();
@ -162,7 +162,7 @@ pub fn vks_manage_post(
let token = token_service.create(&StatelessVerifyToken { fpr });
let link_path = uri!(vks_manage_key(token)).to_string();
let base_uri = request_origin.get_base_uri();
let base_uri = origin.get_base_uri();
if let Err(e) = mail_service.send_manage_token(&i18n, base_uri, fpr_text, &email, &link_path) {
return MyResponse::ise(e);
}
@ -170,25 +170,25 @@ pub fn vks_manage_post(
let ctx = templates::ManageLinkSent {
address: email.to_string(),
};
MyResponse::ok("manage/manage_link_sent", ctx, i18n, request_origin)
MyResponse::ok("manage/manage_link_sent", ctx, i18n, origin)
}
#[post("/manage/unpublish", data="<request>")]
pub fn vks_manage_unpublish(
request_origin: RequestOrigin,
origin: RequestOrigin,
db: &rocket::State<KeyDatabase>,
i18n: I18n,
token_service: &rocket::State<tokens::Service>,
request: Form<forms::ManageDelete>,
) -> MyResponse {
match vks_manage_unpublish_or_fail(request_origin, db, token_service, i18n, request) {
match vks_manage_unpublish_or_fail(origin, db, token_service, i18n, request) {
Ok(response) => response,
Err(e) => MyResponse::ise(e),
}
}
pub fn vks_manage_unpublish_or_fail(
request_origin: RequestOrigin,
origin: RequestOrigin,
db: &rocket::State<KeyDatabase>,
token_service: &rocket::State<tokens::Service>,
i18n: I18n,
@ -200,5 +200,5 @@ pub fn vks_manage_unpublish_or_fail(
db.set_email_unpublished(&verify_token.fpr, &email)?;
counters::inc_address_unpublished(&email);
Ok(vks_manage_key(request_origin, db, i18n, request.token.to_owned(), token_service))
Ok(vks_manage_key(origin, db, i18n, request.token.to_owned(), token_service))
}

8
src/web/vks.rs
View File

@ -195,7 +195,7 @@ fn process_key_single(
pub fn request_verify(
db: &rocket::State<KeyDatabase>,
request_origin: &RequestOrigin,
origin: &RequestOrigin,
token_stateful: &rocket::State<StatefulTokens>,
token_stateless: &rocket::State<tokens::Service>,
mail_service: &rocket::State<mail::Service>,
@ -227,7 +227,7 @@ pub fn request_verify(
for email in emails_requested {
let rate_limit_ok = rate_limiter.action_perform(format!("verify-{}", &email));
if rate_limit_ok {
if send_verify_email(request_origin, &mail_service, &token_stateful, i18n, &verify_state.fpr, &email).is_err() {
if send_verify_email(origin, &mail_service, &token_stateful, i18n, &verify_state.fpr, &email).is_err() {
return UploadResponse::err(&format!("error sending email to {}", &email));
}
}
@ -252,7 +252,7 @@ fn check_tpk_state(
}
fn send_verify_email(
request_origin: &RequestOrigin,
origin: &RequestOrigin,
mail_service: &mail::Service,
token_stateful: &StatefulTokens,
i18n: &I18n,
@ -265,7 +265,7 @@ fn send_verify_email(
mail_service.send_verification(
i18n,
request_origin.get_base_uri(),
origin.get_base_uri(),
fpr.to_string(),
&email,
&token_verify,

12
src/web/vks_api.rs
View File

@ -92,9 +92,9 @@ pub fn upload_json(
#[post("/vks/v1/upload", rank = 2)]
pub fn upload_fallback(
request_origin: RequestOrigin,
origin: RequestOrigin,
) -> JsonErrorResponse {
let error_msg = format!("expected application/json data. see {}/about/api for api docs.", request_origin.get_base_uri());
let error_msg = format!("expected application/json data. see {}/about/api for api docs.", origin.get_base_uri());
JsonErrorResponse(Status::BadRequest, error_msg)
}
@ -116,7 +116,7 @@ fn get_locale(
pub fn request_verify_json(
db: &rocket::State<KeyDatabase>,
langs: &rocket::State<Translations>,
request_origin: RequestOrigin,
origin: RequestOrigin,
token_stateful: &rocket::State<StatefulTokens>,
token_stateless: &rocket::State<tokens::Service>,
mail_service: &rocket::State<mail::Service>,
@ -127,16 +127,16 @@ pub fn request_verify_json(
let json::VerifyRequest { token, addresses, locale } = data.into_inner();
let i18n = get_locale(langs, locale.unwrap_or_default());
let result = vks::request_verify(
db, &request_origin, token_stateful, token_stateless, mail_service,
db, &origin, token_stateful, token_stateless, mail_service,
rate_limiter, &i18n, token, addresses);
upload_ok_json(result)
}
#[post("/vks/v1/request-verify", rank = 2)]
pub fn request_verify_fallback(
request_origin: RequestOrigin,
origin: RequestOrigin,
) -> JsonErrorResponse {
let error_msg = format!("expected application/json data. see {}/about/api for api docs.", request_origin.get_base_uri());
let error_msg = format!("expected application/json data. see {}/about/api for api docs.", origin.get_base_uri());
JsonErrorResponse(Status::BadRequest, error_msg)
}

30
src/web/vks_web.rs
View File

@ -273,14 +273,14 @@ pub async fn quick_upload(
tokens_stateless: &rocket::State<tokens::Service>,
rate_limiter: &rocket::State<RateLimiter>,
i18n: I18n,
request_origin: RequestOrigin,
origin: RequestOrigin,
data: Data<'_>,
) -> MyResponse {
let buf = match data.open(UPLOAD_LIMIT).into_bytes().await {
Ok(buf) => buf.into_inner(),
Err(error) =>
return MyResponse::bad_request("400-plain", anyhow!(error),
i18n, request_origin),
i18n, origin),
};
MyResponse::upload_response_quick(
@ -291,13 +291,13 @@ pub async fn quick_upload(
&rate_limiter,
Cursor::new(buf)
),
i18n, request_origin)
i18n, origin)
}
#[get("/upload/<token>", rank = 2)]
pub fn quick_upload_proceed(
db: &rocket::State<KeyDatabase>,
request_origin: RequestOrigin,
origin: RequestOrigin,
token_stateful: &rocket::State<StatefulTokens>,
token_stateless: &rocket::State<tokens::Service>,
mail_service: &rocket::State<mail::Service>,
@ -306,16 +306,16 @@ pub fn quick_upload_proceed(
token: String,
) -> MyResponse {
let result = vks::request_verify(
db, &request_origin, token_stateful, token_stateless, mail_service,
db, &origin, token_stateful, token_stateless, mail_service,
rate_limiter, &i18n, token, vec!());
MyResponse::upload_response(result, i18n, request_origin)
MyResponse::upload_response(result, i18n, origin)
}
#[post("/upload/submit", format = "application/x-www-form-urlencoded", data = "<data>")]
pub async fn upload_post_form(
db: &rocket::State<KeyDatabase>,
request_origin: RequestOrigin,
origin: RequestOrigin,
tokens_stateless: &rocket::State<tokens::Service>,
rate_limiter: &rocket::State<RateLimiter>,
i18n: I18n,
@ -323,9 +323,9 @@ pub async fn upload_post_form(
) -> MyResponse {
match process_post_form(&db, &tokens_stateless, &rate_limiter, &i18n, data).await {
Ok(response) => MyResponse::upload_response(response,
i18n, request_origin),
i18n, origin),
Err(err) => MyResponse::bad_request("upload/upload", err,
i18n, request_origin),
i18n, origin),
}
}
@ -414,7 +414,7 @@ fn process_multipart(
#[post("/upload/request-verify", format = "application/x-www-form-urlencoded", data="<request>")]
pub fn request_verify_form(
db: &rocket::State<KeyDatabase>,
request_origin: RequestOrigin,
origin: RequestOrigin,
token_stateful: &rocket::State<StatefulTokens>,
token_stateless: &rocket::State<tokens::Service>,
mail_service: &rocket::State<mail::Service>,
@ -424,15 +424,15 @@ pub fn request_verify_form(
) -> MyResponse {
let forms::VerifyRequest { token, address } = request.into_inner();
let result = vks::request_verify(
db, &request_origin, token_stateful, token_stateless, mail_service,
db, &origin, token_stateful, token_stateless, mail_service,
rate_limiter, &i18n, token, vec!(address));
MyResponse::upload_response(result, i18n, request_origin)
MyResponse::upload_response(result, i18n, origin)
}
#[post("/upload/request-verify", format = "multipart/form-data", data="<request>")]
pub fn request_verify_form_data(
db: &rocket::State<KeyDatabase>,
request_origin: RequestOrigin,
origin: RequestOrigin,
token_stateful: &rocket::State<StatefulTokens>,
token_stateless: &rocket::State<tokens::Service>,
mail_service: &rocket::State<mail::Service>,
@ -442,9 +442,9 @@ pub fn request_verify_form_data(
) -> MyResponse {
let forms::VerifyRequest { token, address } = request.into_inner();
let result = vks::request_verify(
db, &request_origin, token_stateful, token_stateless, mail_service,
db, &origin, token_stateful, token_stateless, mail_service,
rate_limiter, &i18n, token, vec!(address));
MyResponse::upload_response(result, i18n, request_origin)
MyResponse::upload_response(result, i18n, origin)
}
#[post("/verify/<token>")]