Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Move methods from ServiceExt to RoutingDsl #160

Merged
merged 1 commit into from
Aug 8, 2021
Merged

Move methods from ServiceExt to RoutingDsl #160

merged 1 commit into from
Aug 8, 2021

Conversation

davidpdrsn
Copy link
Member

@davidpdrsn davidpdrsn commented Aug 8, 2021 •
edited
Loading

Previously, on main, this wouldn't compile:

let app = route("/", get(handler))
    .layer(
        ServiceBuilder::new()
            .timeout(Duration::from_secs(10))
            .into_inner(),
    )
    .handle_error(...)
    .route(...); // <-- doesn't work

That is because handle_error would be
axum::service::ServiceExt::handle_error which returns HandleError<_, _, _, HandleErrorFromService> which does not implement RoutingDsl.
So you couldn't call route. This was caused by
#120.

Basically handle_error when called on a RoutingDsl, the resulting
service should also implement RoutingDsl, but if called on another
random service it should not implement RoutingDsl.

I don't think thats possible by having handle_error on ServiceExt
which is implemented for any service, since all axum routers are also
services by design.

This resolves the issue by removing ServiceExt and moving its methods
to RoutingDsl. Then we have more tight control over what has a
handle_error method.

service::OnMethod now also has a handle_error so you can still
handle errors from random services, by doing
service::any(svc).handle_error(...).

@davidpdrsn davidpdrsn added the C-enhancement Category: A PR with an enhancement label Aug 8, 2021
@davidpdrsn davidpdrsn added this to the 0.2 milestone Aug 8, 2021
@davidpdrsn
Move methods from ServiceExt to RoutingDsl
b3384be 
Previously, on `main`, this wouldn't compile:

```rust
let app = route("/", get(handler))
    .layer(
        ServiceBuilder::new()
            .timeout(Duration::from_secs(10))
            .into_inner(),
    )
    .handle_error(...)
    .route(...); // <-- doesn't work
```

That is because `handle_error` would be
`axum::service::ServiceExt::handle_error` which returns `HandleError<_,
_, _, HandleErrorFromService>` which does _not_ implement `RoutingDsl`.
So you couldn't call `route`. This was caused by
#120.

Basically `handle_error` when called on a `RoutingDsl`, the resulting
service should also implement `RoutingDsl`, but if called on another
random service it should _not_ implement `RoutingDsl`.

I don't think thats possible by having `handle_error` on `ServiceExt`
which is implemented for any service, since all axum routers are also
services by design.

This resolves the issue by removing `ServiceExt` and moving its methods
to `RoutingDsl`. Then we have more tight control over what has a
`handle_error` method.

`service::OnMethod` now also has a `handle_error` so you can still
handle errors from random services, by doing
`service::any(svc).handle_error(...)`.
@davidpdrsn davidpdrsn merged commit 8013165 into main Aug 8, 2021
@davidpdrsn davidpdrsn deleted the remove-service-ext branch August 8, 2021 12:30
@davidpdrsn davidpdrsn mentioned this pull request Aug 23, 2021
Merged
davidpdrsn added a commit that referenced this pull request Aug 23, 2021
@davidpdrsn
Version 0.2.0 (#247)
02e61df 
- Overall:
  - **fixed:** Overall compile time improvements. If you're having issues with compile time
    please file an issue! ([#184](#184)) ([#198](#198)) ([#220](#220))
  - **changed:** Remove `prelude`. Explicit imports are now required ([#195](#195))
- Routing:
  - **added:** Add dedicated `Router` to replace the `RoutingDsl` trait ([#214](#214))
  - **added:** Add `Router::or` for combining routes ([#108](#108))
  - **fixed:** Support matching different HTTP methods for the same route that aren't defined
    together. So `Router::new().route("/", get(...)).route("/", post(...))` now
    accepts both `GET` and `POST`. Previously only `POST` would be accepted ([#224](#224))
  - **fixed:** `get` routes will now also be called for `HEAD` requests but will always have
    the response body removed ([#129](#129))
  - **changed:** Replace `axum::route(...)` with `axum::Router::new().route(...)`. This means
    there is now only one way to create a new router. Same goes for
    `axum::routing::nest`. ([#215](#215))
  - **changed:** Implement `routing::MethodFilter` via [`bitflags`](https://crates.io/crates/bitflags) ([#158](#158))
  - **changed:** Move `handle_error` from `ServiceExt` to `service::OnMethod` ([#160](#160))

  With these changes this app using 0.1:

  ```rust
  use axum::{extract::Extension, prelude::*, routing::BoxRoute, AddExtensionLayer};

  let app = route("/", get(|| async { "hi" }))
      .nest("/api", api_routes())
      .layer(AddExtensionLayer::new(state));

  fn api_routes() -> BoxRoute<Body> {
      route(
          "/users",
          post(|Extension(state): Extension<State>| async { "hi from nested" }),
      )
      .boxed()
  }
  ```

  Becomes this in 0.2:

  ```rust
  use axum::{
      extract::Extension,
      handler::{get, post},
      routing::BoxRoute,
      Router,
  };

  let app = Router::new()
      .route("/", get(|| async { "hi" }))
      .nest("/api", api_routes());

  fn api_routes() -> Router<BoxRoute> {
      Router::new()
          .route(
              "/users",
              post(|Extension(state): Extension<State>| async { "hi from nested" }),
          )
          .boxed()
  }
  ```
- Extractors:
  - **added:** Make `FromRequest` default to being generic over `body::Body` ([#146](#146))
  - **added:** Implement `std::error::Error` for all rejections ([#153](#153))
  - **added:** Add `OriginalUri` for extracting original request URI in nested services ([#197](#197))
  - **added:** Implement `FromRequest` for `http::Extensions` ([#169](#169))
  - **added:** Make `RequestParts::{new, try_into_request}` public so extractors can be used outside axum ([#194](#194))
  - **added:** Implement `FromRequest` for `axum::body::Body` ([#241](#241))
  - **changed:** Removed `extract::UrlParams` and `extract::UrlParamsMap`. Use `extract::Path` instead ([#154](#154))
  - **changed:** `extractor_middleware` now requires `RequestBody: Default` ([#167](#167))
  - **changed:** Convert `RequestAlreadyExtracted` to an enum with each possible error variant ([#167](#167))
  - **changed:** `extract::BodyStream` is no longer generic over the request body ([#234](#234))
  - **changed:** `extract::Body` has been renamed to `extract::RawBody` to avoid conflicting with `body::Body` ([#233](#233))
  - **changed:** `RequestParts` changes ([#153](#153))
      - `method` new returns an `&http::Method`
      - `method_mut` new returns an `&mut http::Method`
      - `take_method` has been removed
      - `uri` new returns an `&http::Uri`
      - `uri_mut` new returns an `&mut http::Uri`
      - `take_uri` has been removed
  - **changed:** Remove several rejection types that were no longer used ([#153](#153)) ([#154](#154))
- Responses:
  - **added:** Add `Headers` for easily customizing headers on a response ([#193](#193))
  - **added:** Add `Redirect` response ([#192](#192))
  - **added:** Add `body::StreamBody` for easily responding with a stream of byte chunks ([#237](#237))
  - **changed:** Add associated `Body` and `BodyError` types to `IntoResponse`. This is
    required for returning responses with bodies other than `hyper::Body` from
    handlers. See the docs for advice on how to implement `IntoResponse` ([#86](#86))
  - **changed:** `tower::util::Either` no longer implements `IntoResponse` ([#229](#229))

  This `IntoResponse` from 0.1:
  ```rust
  use axum::{http::Response, prelude::*, response::IntoResponse};

  struct MyResponse;

  impl IntoResponse for MyResponse {
      fn into_response(self) -> Response<Body> {
          Response::new(Body::empty())
      }
  }
  ```

  Becomes this in 0.2:
  ```rust
  use axum::{body::Body, http::Response, response::IntoResponse};

  struct MyResponse;

  impl IntoResponse for MyResponse {
      type Body = Body;
      type BodyError = <Self::Body as axum::body::HttpBody>::Error;

      fn into_response(self) -> Response<Self::Body> {
          Response::new(Body::empty())
      }
  }
  ```
- SSE:
  - **added:** Add `response::sse::Sse`. This implements SSE using a response rather than a service ([#98](#98))
  - **changed:** Remove `axum::sse`. Its been replaced by `axum::response::sse` ([#98](#98))

  Handler using SSE in 0.1:
  ```rust
  use axum::{
      prelude::*,
      sse::{sse, Event},
  };
  use std::convert::Infallible;

  let app = route(
      "/",
      sse(|| async {
          let stream = futures::stream::iter(vec![Ok::<_, Infallible>(
              Event::default().data("hi there!"),
          )]);
          Ok::<_, Infallible>(stream)
      }),
  );
  ```

  Becomes this in 0.2:

  ```rust
  use axum::{
      handler::get,
      response::sse::{Event, Sse},
      Router,
  };
  use std::convert::Infallible;

  let app = Router::new().route(
      "/",
      get(|| async {
          let stream = futures::stream::iter(vec![Ok::<_, Infallible>(
              Event::default().data("hi there!"),
          )]);
          Sse::new(stream)
      }),
  );
  ```
- WebSockets:
  - **changed:** Change WebSocket API to use an extractor plus a response ([#121](#121))
  - **changed:** Make WebSocket `Message` an enum ([#116](#116))
  - **changed:** `WebSocket` now uses `Error` as its error type ([#150](#150))

  Handler using WebSockets in 0.1:

  ```rust
  use axum::{
      prelude::*,
      ws::{ws, WebSocket},
  };

  let app = route(
      "/",
      ws(|socket: WebSocket| async move {
          // do stuff with socket
      }),
  );
  ```

  Becomes this in 0.2:

  ```rust
  use axum::{
      extract::ws::{WebSocket, WebSocketUpgrade},
      handler::get,
      Router,
  };

  let app = Router::new().route(
      "/",
      get(|ws: WebSocketUpgrade| async move {
          ws.on_upgrade(|socket: WebSocket| async move {
              // do stuff with socket
          })
      }),
  );
  ```
- Misc
  - **added:** Add default feature `tower-log` which exposes `tower`'s `log` feature. ([#218](#218))
  - **changed:** Replace `body::BoxStdError` with `axum::Error`, which supports downcasting ([#150](#150))
  - **changed:** `EmptyRouter` now requires the response body to implement `Send + Sync + 'static'` ([#108](#108))
  - **changed:** `Router::check_infallible` now returns a `CheckInfallible` service. This
    is to improve compile times ([#198](#198))
  - **changed:** `Router::into_make_service` now returns `routing::IntoMakeService` rather than
    `tower::make::Shared` ([#229](#229))
  - **changed:** All usage of `tower::BoxError` has been replaced with `axum::BoxError` ([#229](#229))
  - **changed:** Several response future types have been moved into dedicated
    `future` modules ([#133](#133))
  - **changed:** `EmptyRouter`, `ExtractorMiddleware`, `ExtractorMiddlewareLayer`,
    and `QueryStringMissing` no longer implement `Copy` ([#132](#132))
  - **changed:** `service::OnMethod`, `handler::OnMethod`, and `routing::Nested` have new response future types ([#157](#157))
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Reviewers
No reviews
Assignees
No one assigned
Labels
C-enhancement Category: A PR with an enhancement
Projects
None yet
Milestone
0.2
Development

Successfully merging this pull request may close these issues.
1 participant
@davidpdrsn