@mzr: Probably not out of the box. I'd suggest looking at
bind_server (source) to see (a) if it would be enough, (b) how it's dont internally.
Hi,
Their is something I don't understand in
the-benchmarker/web-frameworks#3690
Their is something I don't understand in
Cargo.lock, should not in fix / expose feature from hyper ? I have no rust skill but hyper is in 0.14 so we need to fix version in Cargo.tomlthe-benchmarker/web-frameworks#3690
@waghanza: gotham re-exports the hyper crate, so I strongly advise you use
gotham::hyper and don't depend on your own version of hyper
@jugglerchris: I don't think the diesel middleware currently supports this, so for now your best bet is probably to create a temporary file and use that as the database. Feel free to open an issue/PR to improve this
Next question... what do people use for the session middleware backend? I guess it's probably not much effort wrapping a
gotham_middleware_diesel table, but I guess I'd expect someone to have done so already. :-) (In the absence of a pre-existing one the MemoryBackendwill realistically be fine for my one-off application for a child's distributed birthday party)
it looks like travis currently refuses to run on our repository - does anyone know why that is?
@seanpianka: I don't think you need to include
hyper in your Cargo.toml file if you use gotham
@mjhouse: that depends... for a 404 returned by the router because there was no matching path, there's no convenient way to catch that error unfortunately. For other errors like 500, assuming they're not caused by a panic, you could use a middleware that checks the returned response from the handler and creates a new response if it was a server error
Is there a way I can wildcard capture all routes that don't have a handler?
iirc you can add a wildcard handler that calls a second router (since routers are also just handlers) and then add your middleware to the first router
@alsuren Hey, I remember this problem in gotham you were talking about a few months ago. https://users.rust-lang.org/t/storing-async-functions-which-have-references-possibly-hrtb-related/56262. Thought you would want to know.
1 reply
I think this was even before that
I wasn't following
0.5.0 release since I gave up on gotham
hey guys, I'm a little confused on how to pre-populate the state before handing it to a response handler. For example, use case would be if i have a mpsc channel and want to pass over a clone of the transmitter to the handler via it's state. Any thoughts/ resources you guys could point me to?
So far, seems like i would have to use middleware for it, but not sure if that's the simplest way to do it
if you want to put a type into the state after the router and before the request handler, you'll have to use a middleware. The easiest middleware you can use is
StateMiddleware that just puts a clone of the value you initialize it with into the state for every request
@bmoelk: I think there's no such example as the recommended way to test handlers is through the test server. However, if you really want to test the handlers directly, you can use
State::with_new (note that this method is public but hidden from documentation), similar to how we test route matchers: https://github.com/gotham-rs/gotham/blob/master/gotham/src/router/route/matcher/content_type.rs#L150
Note However that this means no middlewares will run (so no cookie parsing etc) and you will have to place all the required parts into the state yourself (like headers, request body, etc)
ok, I attempted to use
State::with_new but ran into some core Rust newbie issues trying to get it all to work properly. I gave up and started testing the full request, which I have working. But that seemed somewhat lacking because I wanted to test the actual changes made to the DB however with_test_transactions it seems that's not possible. I'll give it another go and come back with specific issues. Thanks!
I don't know how to work through this issue:
--> src/handlers.rs:194:36
|
194 | my_handler(state);
| ^^^^^^ move occurs because
error[E0507]: cannot move out ofstate` which is behind a mutable reference--> src/handlers.rs:194:36
|
194 | my_handler(state);
| ^^^^^^ move occurs because
*state has type gotham::state::State, which does not implement the Copy trait`
handler declaration like:
pub fn my_handler(state: State) -> (State, impl IntoResponse) {
@bmoelk: Sorry, that signature is actually incompatible. This is a short example how you could do it if you really want to: https://gist.github.com/msrd0/5c6ecbfaf2934b90a3cbb0706486eb6f
Do note however that this way of testing wasn't designed for handlers, so if you for example try to use helper functions like
create_empty_response, they might panic and you can't really do anything about it
If at all possible, I'd recommend you place the logic for your database or whatever part you want to test into a separate function, test that independent of gotham, and use that tested function for your handler which you can then test using the test server provided by gotham
Hello all! I'm new to Rust (and Gotham!) and am building a server using Gotham - and loving it so far.
I have a small question - I've set up Gotham to use asynchronous handlers and I find that a lot of my await blocks have code repetition:
async fn next_node(state: State) -> HandlerResult {
let resp = reqwest::get("http://livenode121:8000/successor/").await;
let resp = match resp {
Ok(resp) => resp,
Err(e) => return Err((state, format!(" {}", e))),
};
let result = resp.text().await;
let result = match result {} // same code block as above!
let response = create_response(&state, StatusCode::OK, mime::TEXT_PLAIN, result);
Ok((state, response))
}How do I avoid this repetition? I'd love to use await? but that doesn't work as Rust cannot figure out how to return the state from the ?.
(Also, I could use
await.unwrap() but I doubt that's idiomatic and the intended way to do things)
@a3y3: Try changing your method signature to
async fn next_node(state: &mut State) -> Result<Response<Body>, HandlerError> and register them using .to_async_borrowing. That way you should be able to use the ? shorthand