Thruster

스러스터

웹 사이트에서 예제와 연습을 시작하십시오!

빠르고 직관적 인 Rust 웹 프레임 워크

문서를 읽을 시간이 없습니까? 체크 아웃

• 스러 스터를 사용해야하는 이유
• Thruster를 사용해서는 안되는 이유 (확실히 이것을 읽으십시오)

✅ 안정적인 실행 ✅ ✅ 빠르게 실행

선적 서류 비치

특징

• 비동기/를 염두에두고 제작되었습니다
• 하이퍼 호환
• SSL 준비
• 테스트 가능
• 정적 파일 서빙
• Socketio
• GRPC 및보다 실험적인 비톤 기반 GRPC
• 의존성 주입

동기 부여

Thruster는 개발자가 프로젝트 및 팀 전체에서 생산적이고 일관되게하는 것을 목표로하는 웹 프레임 워크입니다. 목표는 다음과 같습니다.

• 수행자
• 단순한
• 직관적입니다

스러스터도 마찬가지입니다

• unsafe 사용하지 않습니다
• 안정적인 녹에서 작동합니다

빠른

스러 스터는 다른 서버 백엔드로 실행할 수 있으며 그 위에 멋진 패키지 레이어를 나타냅니다. 이는 집에서 자란 HTTP 엔진 인 Hyper, Actix 또는 심지어 Thrusterserver와 같은 최신의 가장 큰 변화를 따라갈 수 있음을 의미합니다.

직관적입니다

KOA 및 Express와 같은 프레임 워크를 기반으로 스러스터는 발전하는 즐거움을 목표로합니다.

예

예제 cargo run --example <example-name> . 예를 들어, cargo run --example hello_world 및 Open http : // localhost : 4321/

미들웨어 기반

새로운 비스듬한 코드 작업을하는 핵심 부분은 #[middleware_fn] 속성 (중간웨어를 표시하여 스러스터가 구축 한 안정적인 선물 버전과 호환되도록 m! 실제 경로에서 매크로.

비동기를 기다리는 간단한 예는 다음과 같습니다.

 use std :: boxed :: Box ;
use std :: future :: Future ;
use std :: pin :: Pin ;
use std :: time :: Instant ;

use thruster :: { App , BasicContext as Ctx , Request } ;
use thruster :: { m , middleware_fn , MiddlewareNext , MiddlewareResult , Server , ThrusterServer } ;

# [ middleware_fn ]
async fn profile ( context : Ctx , next : MiddlewareNext < Ctx > ) -> MiddlewareResult < Ctx > {
    let start_time = Instant :: now ( ) ;

    context = next ( context ) . await ;

    let elapsed_time = start_time . elapsed ( ) ;
    println ! (
        "[{}μs] {} -- {}" ,
        elapsed_time . as_micros ( ) ,
        context . request . method ( ) ,
        context . request . path ( )
    ) ;

    Ok ( context )
}

# [ middleware_fn ]
async fn plaintext ( mut context : Ctx , _next : MiddlewareNext < Ctx > ) -> MiddlewareResult < Ctx > {
    let val = "Hello, World!" ;
    context . body ( val ) ;
    Ok ( context )
}

# [ middleware_fn ]
async fn four_oh_four ( mut context : Ctx , _next : MiddlewareNext < Ctx > ) -> MiddlewareResult < Ctx > {
    context . status ( 404 ) ;
    context . body ( "Whoops! That route doesn't exist!" ) ;
    Ok ( context )
}

# [ tokio :: main ]
fn main ( ) {
    println ! ( "Starting server..." ) ;

    let mut app = App :: < Request , Ctx , ( ) > :: new_basic ( ) ;

    app . get ( "/plaintext" , m ! [ profile , plaintext ] ) ;
    app . set404 ( m ! [ four_oh_four ] ) ;

    let server = Server :: new ( app ) ;
    server . build ( "0.0.0.0" , 4321 ) . await ;
}

오류 처리

다음은 좋은 예입니다

 use thruster :: errors :: ThrusterError as Error ;
use thruster :: proc :: { m , middleware_fn } ;
use thruster :: { map_try , App , BasicContext as Ctx , Request } ;
use thruster :: { MiddlewareNext , MiddlewareResult , MiddlewareReturnValue , Server , ThrusterServer } ;

# [ middleware_fn ]
async fn plaintext ( mut context : Ctx , _next : MiddlewareNext < Ctx > ) -> MiddlewareResult < Ctx > {
    let val = "Hello, World!" ;
    context . body ( val ) ;
    Ok ( context )
}

# [ middleware_fn ]
async fn error ( mut context : Ctx , _next : MiddlewareNext < Ctx > ) -> MiddlewareResult < Ctx > {
    let res = "Hello, world" . parse :: < u32 > ( )
        . map_err ( |_| {
            let mut context = Ctx :: default ( ) ;
            
            context . status ( 400 ) ;

            ThrusterError {
                context ,
                message : "Custom error message" . to_string ( ) ,
                cause : None ,
            }
        } ? ;

    context . body ( & format ! ( "{}" , non_existent_param ) ) ;

    Ok ( context )
}

# [ tokio :: main ]
fn main ( ) {
    println ! ( "Starting server..." ) ;

    let app = App :: < Request , Ctx , ( ) > :: new_basic ( )
        . get ( "/plaintext" , m ! [ plaintext ] )
        . get ( "/error" , m ! [ error ] ) ;

    let server = Server :: new ( app ) ;
    server . build ( "0.0.0.0" , 4321 ) . await ;
} 

테스트

Thruster는 엔드 포인트를 테스트 할 수있는 쉬운 테스트 스위트를 제공합니다. 다음과 같이 testing 모듈을 포함시킵니다.

 let mut app = App :: < Request , Ctx , ( ) > :: new_basic ( ) ;

.. .

app . get ( "/plaintext" , m ! [ plaintext ] ) ;

.. .

let result = testing :: get ( app , "/plaintext" ) ;

assert ! ( result . body == "Hello, World!" ) ; 

나만의 미들웨어 모듈을 만드십시오

미들웨어는 매우 쉽게 만들 수 있습니다! 단순히 함수를 작성하고 모듈 수준에서 내보내십시오. 아래에는 요청을 프로파일 링 할 수있는 미들웨어가 표시됩니다.

 # [ middleware_fn ]
async fn profiling < C : ' static + Context + Send > (
    mut context : C ,
    next : MiddlewareNext < C > ,
) -> MiddlewareResult < C > {
    let start_time = Instant :: now ( ) ;

    context = next ( context ) . await ? ;

    let elapsed_time = start_time . elapsed ( ) ;
    info ! ( "[{}μs] {}" , elapsed_time . as_micros ( ) , context . route ( ) ) ;

    Ok ( context )
}

예를 들어, 컨텍스트에 저장된보다 특정한 데이터를 허용하고 싶을 수도 있습니다. 예를 들어, 다른 중간 전쟁에서 나중에 사용하기 위해 쿼리 매개 변수를 해시 맵으로 수화 할 수 있기를 원할 것입니다. 이를 위해, 당신은 하류 하류가 준수 해야하는 맥락에 대한 추가 특성을 만들 수 있습니다. 제공된 query_params 미들웨어를 확인하십시오.

기타 또는 맞춤형 백엔드

Thruster는 위의 하이퍼 스 니펫에서 어떤 종류의 서버 위에 라우팅 레이어를 제공 할 수 있습니다. 서버가 ThrusterServer 구현하는 한 이것은 모든 백엔드에 광범위하게 적용될 수 있습니다.

 use async_trait :: async_trait ;

# [ async_trait ]
pub trait ThrusterServer {
    type Context : Context + Send ;
    type Response : Send ;
    type Request : RequestWithParams + Send ;

    fn new ( App < Self :: Request , Self :: Context > ) -> Self ;
    async fn build ( self , host : & str , port : u16 ) ;
}

다음이 필요합니다.

• 서버를 만드는 쉬운 방법.
• 비동기 런타임에로드 할 수있는 미래로 서버를 구축하는 기능.

build 기능 내에서 서버 구현은 다음과 같습니다.

• 연결을 위해 일종의 리스너를 시작하십시오
• Call let matched = app.resolve_from_method_and_path(<some method>, <some path>); (이것은 실제 라우팅을 제공합니다.)
• app.resolve(<incoming request>, matched) 호출하십시오 (이로 인해 체인 미들웨어가 실행됩니다.)

스러 스터를 사용해야하는 이유

• 뒷면을 마음대로 변경하십시오. 상자 밖에서, Thruster는 이제 Actix-Web, Hyper 또는 Custom Backend를 사용할 수 있습니다.
• Thruster는 프레임 워크 수준에서 테스트를 지원합니다
• @trezm은 아무도 PRS를 만들거나 문제를 여는 경우 외로워집니다.
• Thruster는 루트 가드처럼 더 많은 미들웨어 중심의 개념에 더 간결합니다. 이 예제를 Actix에서 가져와 IPS를 제한하십시오.

 fn ip_guard ( head : & RequestHead ) -> bool {
    // Check for the cloudflare IP header
    let ip = if let Some ( val ) = head . headers ( ) . get ( CF_IP_HEADER ) {
        val . to_str ( ) . unwrap_or ( "" ) . to_owned ( )
    } else if let Some ( val ) = head . peer_addr {
        val . to_string ( )
    } else {
        return false ;
    } ;

    "1.2.3.4" . contains ( & ip )
}

# [ actix_web :: post ( "/ping" ) ]
async fn ping ( ) -> Result < HttpResponse , UserPersonalError > {
    Ok ( HttpResponse :: Ok ( ) . body ( "pong" ) )
}

.. .
        web :: scope ( "/*" )
            // This is confusing, but we catch all routes that _aren't_
            // ip guarded and return an error.
            . guard ( guard :: Not ( ip_guard ) )
            . route ( "/*" , web :: to ( HttpResponse :: Forbidden ) ) ,
    )
    . service ( ping ) ;
.. .

여기서 스러 스터입니다.

 # [ middleware_fn ]
async fn ip_guard ( mut context : Ctx , next : MiddlewareNext < Ctx > ) -> MiddlewareResult < Ctx > {
    if "1.2.3.4" . contains ( & context . headers ( ) . get ( "Auth-Token" ) . unwrap_or ( "" ) ) {
        context = next ( context ) . await ? ;

        Ok ( context )
    } else {
        Err ( Error :: unauthorized_error ( context ) )
    }

}

# [ middleware_fn ]
async fn ping ( mut context : Ctx , _next : MiddlewareNext < Ctx > ) -> MiddlewareResult < Ctx > {
    context . body ( "pong" ) ;
    Ok ( context )
}

.. .
    app . get ( "/ping" , m ! [ ip_guard , plaintext ] ) ;
.. .

조금 더 직접적인 것은 좋습니다!

스러 스터를 사용해서는 안된 이유

• 유지 관리자는 거의 없습니다 (거의 하나만.)
• 훨씬 더 많은 전투 테스트를 거친 다른 프로젝트가 있습니다. Thruster는 생산에 사용되고 있지만, 당신이 알고 있거나 중요한 곳은 없습니다.
• 사악한 스마트에 의해 최적화되지 않았습니다. @trezm은 최선을 다하지만 개에 의해 계속 산만 해지고 있습니다.
• 조심스럽게,이 프레임 워크 할 수 있습니다 훌륭 하지만 확실히 다른 사람들처럼 찌르고 자극을받지 않았습니다. 당신의 도움은 그것을보다 안전하고 강력하게 만드는 데 먼 길을 갈 수 있지만, 우리는 아직 거기에 없을 수도 있습니다.

멀리 있다면 읽어 주셔서 감사합니다! 항상 자유롭게 연락하십시오.