style(Backend): 🎨 manual clippy

Author: Eason0729

backend/Cargo.toml

@@ -130,6 +130,6 @@ optional = true
 features = ["runtime-tokio-rustls", "sqlx-sqlite", "with-chrono"]
 
 [features]
-default = ["debug"]
+default = ["insecure-print"]
 standalone = ["dep:migration", "dep:sea-orm-migration", "dep:sea-orm-cli"]
-debug = ["sea-orm/debug-print"]
+insecure-print = ["sea-orm/debug-print"]

backend/src/controller/duplicate.rs

@@ -10,7 +10,7 @@ use grpc::backend::StateCode as BackendCode;
 use sea_orm::{ActiveModelTrait, ActiveValue, DatabaseConnection, EntityTrait, QueryOrder};
 use thiserror::Error;
 use tonic::Status;
-use tracing::{instrument, Instrument, Span};
+use tracing::{instrument, Instrument};
 use uuid::Uuid;
 
 use self::{pubsub::PubSub, route::*};
@@ -22,9 +22,6 @@ use grpc::{
     judger::*,
 };
 
-const PALYGROUND_TIME: u64 = 500 * 1000;
-const PALYGROUND_MEM: u64 = 256 * 1024 * 1024;
-
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("judger temporarily unavailable")]

backend/src/controller/judger/mod.rs

@@ -4,7 +4,6 @@
 //! include intergated test
 
 pub mod crypto;
-pub mod duplicate;
 pub mod imgur;
 pub mod judger;
 pub mod rate_limit;

backend/src/controller/mod.rs

@@ -75,7 +75,6 @@ impl Bucket {
 
 /// Policy of resource acquisition
 trait AcquisitionPolicy {
-    const BUCKET_WIDTH: usize = BUCKET_WIDTH;
     /// How many burst request is allowed
     const BURST: NonZeroU32;
     /// How many fill per minute
@@ -145,7 +144,7 @@ impl RateLimitController {
         Self {
             ip_blacklist: Cache::new(BUCKET_WIDTH),
             user_limiter: Arc::new(LoginPolicy::key()),
-            ip_limiter: Arc::new(LoginPolicy::key()),
+            ip_limiter: Arc::new(GuestPolicy::key()),
             blacklist_limiter: Arc::new(BlacklistPolicy::direct()),
             trusts: trusts.to_vec(),
         }

backend/src/controller/rate_limit.rs

@@ -7,7 +7,7 @@ use sea_orm::*;
 use spin::Mutex;
 use std::{ops::Deref, sync::Arc};
 use tokio::time;
-use tracing::{instrument, Instrument, Span};
+use tracing::{instrument, Instrument};
 
 use crate::report_internal;
 

backend/src/controller/token.rs

@@ -1,10 +1,10 @@
-use super::tools::*;
+use super::*;
 
 use grpc::backend::announcement_server::*;
 
 use crate::{
     entity::announcement::{Paginator, *},
-    entity::*,
+    entity::contest,
     util::time::into_prost,
 };
 

backend/src/endpoint/announcement.rs

@@ -1,4 +1,4 @@
-use super::tools::*;
+use super::*;
 
 use grpc::backend::chat_server::*;
 

backend/src/endpoint/chat.rs

@@ -1,4 +1,4 @@
-use super::tools::*;
+use super::*;
 
 use crate::entity::{
     contest::{Paginator, *},

backend/src/endpoint/contest.rs

@@ -1,8 +1,8 @@
-use super::tools::*;
+use super::*;
 
 use grpc::backend::education_server::*;
 
-use crate::entity::{education::Paginator, education::*, *};
+use crate::entity::{education::Paginator, education::*, problem};
 
 impl<'a> From<WithAuth<'a, Model>> for EducationFullInfo {
     fn from(value: WithAuth<'a, Model>) -> Self {

backend/src/endpoint/education.rs

@@ -1,4 +1,4 @@
-use super::tools::*;
+use super::*;
 
 use grpc::backend::image_server::*;
 

backend/src/endpoint/imgur.rs

@@ -14,26 +14,17 @@ mod submit;
 mod testcase;
 mod token;
 mod user;
-mod util;
 
-mod tools {
-    pub use crate::NonZeroU32;
-    pub use grpc::backend::{Id, Order, *};
-    pub use sea_orm::*;
-    pub use std::ops::Deref;
-    pub use tonic::*;
-    pub use tracing::*;
-    pub use uuid::Uuid;
+use crate::NonZeroU32;
+use grpc::backend::{Id, Order, *};
+use sea_orm::*;
+use std::ops::Deref;
+use tonic::*;
+use tracing::*;
+use uuid::Uuid;
 
-    pub use crate::entity::util::{
-        filter::*,
-        paginator::{PaginateRaw, Remain},
-    };
-    pub use crate::util::with::*;
-    pub use crate::util::{auth::RoleLv, bound::BoundCheck, duplicate::*, error::Error, time::*};
-    pub use crate::{fill_active_model, fill_exist_active_model, server::ArcServer, TonicStream};
-    pub use tracing::{Instrument, Level};
-}
-
-// FIXME: currently we report transaction error as internal error,
-// but we should report it as bad request, or even a give it an retry logic
+use crate::entity::util::filter::*;
+use crate::util::with::*;
+use crate::util::{auth::RoleLv, bound::BoundCheck, duplicate::*, error::Error, time::*};
+use crate::{fill_active_model, fill_exist_active_model, server::ArcServer, TonicStream};
+use tracing::{Instrument, Level};

backend/src/endpoint/mod.rs

@@ -1,4 +1,4 @@
-use super::tools::*;
+use super::*;
 
 use grpc::backend::playground_server::*;
 use grpc::backend::*;

backend/src/endpoint/playground.rs

@@ -1,7 +1,7 @@
-use super::tools::*;
+use super::*;
 use grpc::backend::problem_server::*;
 
-use crate::entity::{problem::Paginator, problem::*, *};
+use crate::entity::{contest, problem::Paginator, problem::*};
 
 impl<'a> From<WithAuth<'a, Model>> for ProblemFullInfo {
     fn from(value: WithAuth<'a, Model>) -> Self {

backend/src/endpoint/problem.rs

@@ -1,13 +1,13 @@
-use super::tools::*;
+use super::*;
 
 use crate::controller::judger::SubmitBuilder;
 use crate::util::code::Code;
-use grpc::backend::submit_server::*;
-use grpc::backend::StateCode as BackendCode;
+use grpc::backend::{submit_server::*, StateCode as BackendCode};
 
 use crate::entity::{
+    contest, problem, submit,
     submit::{Paginator, *},
-    *,
+    user,
 };
 use tokio_stream::wrappers::ReceiverStream;
 

backend/src/endpoint/submit.rs

@@ -1,10 +1,10 @@
-use super::tools::*;
+use super::*;
 
 use grpc::backend::testcase_server::*;
 
 use crate::entity::{
+    problem,
     testcase::{Paginator, *},
-    *,
 };
 
 impl<'a> From<WithAuth<'a, Model>> for TestcaseFullInfo {
@@ -118,7 +118,6 @@ impl Testcase for ArcServer {
     )]
     async fn update(&self, req: Request<UpdateTestcaseRequest>) -> Result<Response<()>, Status> {
         let (auth, req) = self.rate_limit(req).in_current_span().await?;
-        let (_, perm) = auth.assume_login()?;
         req.bound_check()?;
 
         req.get_or_insert(|req| async move {

backend/src/endpoint/testcase.rs

@@ -1,13 +1,12 @@
 use std::num::NonZeroU32;
 use std::time::Duration;
 
-use super::tools::*;
+use super::*;
 
 use grpc::backend::token_server::*;
 
 use crate::entity::token::*;
-use crate::entity::*;
-use crate::util::rate_limit::RateLimit;
+use crate::{entity::user, util::rate_limit::RateLimit};
 
 const TOKEN_LIMIT: u64 = 16;
 
@@ -73,7 +72,7 @@ impl Token for ArcServer {
         if self.crypto.hash_eq(req.password.as_str(), &model.password) {
             let dur =
                 chrono::Duration::from_std(Duration::from_secs(req.expiry.unwrap_or(60 * 60 * 12)))
-                    .map_err(|err| Error::BadArgument("expiry"))?;
+                    .map_err(|_| Error::BadArgument("expiry"))?;
             let (token, expiry) = self.token.add(&model, dur).in_current_span().await?;
 
             Ok(Response::new(TokenInfo {
@@ -93,7 +92,7 @@ impl Token for ArcServer {
         err(level = "debug", Display)
     )]
     async fn refresh(&self, req: Request<RefreshRequest>) -> Result<Response<TokenInfo>, Status> {
-        let (auth, bucket) = self.parse_auth(&req).in_current_span().await?;
+        let (_, bucket) = self.parse_auth(&req).in_current_span().await?;
         let (meta, _, req) = req.into_parts();
         bucket.cost(NonZeroU32::new(req.get_cost()).unwrap())?;
 
@@ -112,7 +111,7 @@ impl Token for ArcServer {
                 let dur = chrono::Duration::from_std(Duration::from_secs(
                     req.expiry.unwrap_or(60 * 60 * 12),
                 ))
-                .map_err(|err| Error::BadArgument("expiry"))?;
+                .map_err(|_| Error::BadArgument("expiry"))?;
 
                 self.token.remove(token.to_string()).await?;
                 let (token, expiry) = self.token.add(&user, dur).in_current_span().await?;

backend/src/endpoint/token.rs

@@ -1,4 +1,4 @@
-use super::tools::*;
+use super::*;
 
 use grpc::backend::user_server::*;
 
@@ -97,7 +97,7 @@ impl User for ArcServer {
         let (auth, req) = self.rate_limit(req).in_current_span().await?;
         req.bound_check()?;
 
-        let (user_id, perm) = auth.assume_login()?;
+        let perm = auth.perm();
         perm.super_user()?;
 
         req.get_or_insert(|req| async move {
@@ -151,7 +151,7 @@ impl User for ArcServer {
         let (auth, req) = self.rate_limit(req).in_current_span().await?;
         req.bound_check()?;
 
-        let (user_id, perm) = auth.assume_login()?;
+        let perm = auth.perm();
         perm.admin()?;
 
         req.get_or_insert(|req| async move {

backend/src/endpoint/user.rs

@@ -1,8 +1,6 @@
 use super::*;
 use grpc::backend::list_announcement_request::Sort;
 
-pub static NAME: &str = "announcement";
-
 #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq)]
 #[sea_orm(table_name = "announcement")]
 pub struct Model {