Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Repo info
Activity
  • May 08 14:35

    msrd0 on master

    Send the State to the session b… (compare)

  • May 08 14:35
    msrd0 closed #468
  • May 08 14:34
    msrd0 milestoned #467
  • May 08 14:32
    msrd0 labeled #467
  • May 08 14:32
    msrd0 commented #467
  • May 08 14:28
    msrd0 auto_merge_enabled #468
  • May 08 14:22
    msrd0 milestoned #468
  • May 08 14:22
    msrd0 unlabeled #468
  • May 08 14:21
    codecov[bot] commented #468
  • May 08 14:21
    msrd0 synchronize #468
  • May 06 22:06
    StephenWakely commented #468
  • May 02 09:05
    rp- commented #542
  • May 02 00:05
    msrd0 labeled #542
  • May 02 00:05
    msrd0 commented #542
  • May 01 20:40
    rp- opened #542
  • Apr 29 16:18

    dependabot[bot] on cargo

    (compare)

  • Apr 29 16:18

    msrd0 on master

    Update time requirement from 0.… (compare)

  • Apr 29 16:18
    msrd0 closed #541
  • Apr 29 16:09
    msrd0 auto_merge_enabled #541
  • Apr 29 16:07
    msrd0 synchronize #541
Dominic
@msrd0:msrd0.de
[m]
it looks like travis currently refuses to run on our repository - does anyone know why that is?
Sean Pianka
@seanpianka
Hello, should I be using hyper included in my cargo.toml, or the re-exported hyper from gotham?
Dominic
@msrd0:msrd0.de
[m]
@seanpianka: I don't think you need to include hyper in your Cargo.toml file if you use gotham
Michael House
@mjhouse
Hey, does gotham have any support for error handlers? (404,500 etc.)
Dominic
@msrd0:msrd0.de
[m]
@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
Michael House
@mjhouse
@msrd0:msrd0.de yeah, I did that. For deliberate failures (a handler fails to find a template or something) it works fine. But when the user goes to a page that doesn't exist, I just get a white screen and a 404 in the console.
Is there a way I can wildcard capture all routes that don't have a handler?
Dominic
@msrd0:msrd0.de
[m]
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
Michael House
@mjhouse
@msrd0:msrd0.de that might do it.
Michael House
@mjhouse
@msrd0:msrd0.de thanks man.
Dominic
@msrd0:msrd0.de
[m]
you're welcome
Michael House
@mjhouse
@msrd0:msrd0.de It worked.
Pavan Kumar Sunkara
@pksunkara
@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
tanriol
@tanriol:matrix.org
[m]
@pksunkara: Do you remember to_async_borrowing?
Pavan Kumar Sunkara
@pksunkara
@tanriol:matrix.org No
I think this was even before that
Pavan Kumar Sunkara
@pksunkara
But yeah, I guess people were looking for that to implement the to_async_borrowing
I wasn't following 0.5.0 release since I gave up on gotham
Marwan Rabbâa
@waghanza
congrats for new release @msrd0
1 reply
Rohan Gautam
@RohanGautam
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
Dominic
@msrd0:msrd0.de
[m]
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
tanriol
@tanriol:matrix.org
[m]
@alsuren: Thank you for the link :-)
Brian Moelk
@bmoelk
I'm hacking on my first gotham project (and new to rust), is there an example on how to unit test handlers directly?
Dominic
@msrd0:msrd0.de
[m]
@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)
Brian Moelk
@bmoelk
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!
Brian Moelk
@bmoelk
I don't know how to work through this issue: 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) {
Dominic
@msrd0:msrd0.de
[m]
@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
Brian Moelk
@bmoelk
So you're saying I should write clean code that can be easily tested? :)
Dominic
@msrd0:msrd0.de
[m]
basically xD
Brian Moelk
@bmoelk
Thanks for the example, that works for me.
Soham Dongargaonkar
@a3y3

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)
Dominic
@msrd0:msrd0.de
[m]
@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
Soham Dongargaonkar
@a3y3
Seems to work, thanks @msrd0:msrd0.de!
Soham Dongargaonkar
@a3y3

Hi, I believe I now have a strong understanding of Gotham's fundamentals. However, with my knowledge, I'm kind of stuck on what I wish to achieve.
I won't go into too many details of what I am trying to do to keep things simple, but basically the gist is that my webserver needs to contact its own APIs as part of the startup process.
So here's a snippet of the code:

fn main() {
    let chord = initialize_node();
    let addr = format!("0.0.0.0:{}", PORT);
    println!("Listening for requests at http://{}", addr);
    gotham::start(addr, router(chord));
    // now that we know the webserver is up and running, do something else with `chord`.
    chord.update_others()
}

Basically, how do I ensure that the update_others() function is called only when the webserver is up and running? Is this possible?

tanriol
@tanriol:matrix.org
[m]
@a3y3: Note that gotham::start actually both starts the server and runs it until termination, so running something after it does not match your use case.
By "up and running" do you mean "the sockets are ready to accept connections" or something different?
Dominic
@msrd0:msrd0.de
[m]
This is what gotham ultimately calls to start the server, and it is guaranteed to never return: https://github.com/gotham-rs/gotham/blob/master/gotham/src/lib.rs#L100
Soham Dongargaonkar
@a3y3
Yes, by up and running, I mean that my APIs can be called from anywhere (including by the server itself)
So there's no way to achieve what I want? I might look into using thread::spawn() then, with a small thread.sleep so that by the time the thread starts processing stuff, the server should have started accepting connections. Shitty solution, but looks like it can't be helped.
tanriol
@tanriol:matrix.org
[m]
You aren't doing that just for testing, are you?
If this is for testing, note that Gotham has a TestServer for that :-)
jman
@jman:kotze.city17.xyz
[m]
@a3y3: as a side-thought, you might consider for your use case wrapping the server startup with a service management (example docker, systemd, ...) and chain a call to the server itself by the service that handles the startup
Soham Dongargaonkar
@a3y3
Thanks for the suggestions everyone. No, this isn't for testing (I'm basically trying to model Chord, a distributed hash table protocol, using webservers). Might consider using the docker approach if the thread idea doesn't work out.