Middleware Examples?

[seikosantana]

I'm having fun trying out Grapevine, but unfortunately for now it lacks documentation and examples. Perhaps it is why some is sticking with Grapevine 4, but I'm interested with the middleware. I couldn't find anything about that, but what I have in mind is that it is something like Express JS' middleware. I'm trying to validate headers on each request except for some routes. Is there any examples for that, or something similar, where I can decide to continue the routing or not?

Thanks in advance!

[scottoffen]

Yes. The easiest way to do this it to hook into the Router.BeforeRoutingAsync event handler.

In your startup class:

public void ConfigureServer(IRestServer server)
{
    // These handlers are executed in the order that they are registered
    server.Router.BeforeRoutingAsync += MyRoutingEventHandler;
}

And then somewhere else in your code:

public async Task MyRoutingEventHandler(IHttpContext context)
{
    // do whatever you want to do here
    // if you don't want to continue to the routing, then you need to send an response here
}

The other places you can hook into the request/response lifecycle are:

• RestServer.OnRequestAsync will run when the request is received, useful if you want to do something before static content is served.
• Router.BeforeRoutingAsync will run before the request is routed
• Router.AfterRoutingAsync will run after the request is routed even if the route has been responded to

You can also hook into the server start/stop using

• Server.BeforeStarting
• Server.AfterStarting
• Server.BeforeStopping
• Server.AfterStopping

Note that, unlike the request/response lifecycle hooks, these event handlers are NOT async

[seikosantana]

Thanks.

I see, the middleware concept isn't really close to what Express Js have. To make it clear, we can't assign more than one route handlers and use something like next function to continue the invocation of the next middleware or handler?

[scottoffen]

Not currently, no. All of the handlers will be invoked in the order they were added.

[seikosantana]

But if that's the case, can i at least prevent it to invoke the next handler?

[scottoffen]

Specifically with routing, if you want to stop execution of the before routing event handlers AND not do any routing, you can just throw an exception. You can optionally set the status code of the response and create a custom handler for that status code when an exception is throw, but this might be overkill for what you want to do. If this is exactly what you want to do, I can provide sample code on how to do that as well.

While Grapevine is inspired by ExpressJS, it isn't a direct analog. This is primarily because I want to use conventions that are familiar to .NET developers - the target audience for the library. Ergo, the use of event and event handlers to hook into the flow of the application.

Now, the way C# implements events would typically be something like this:

public class SampleEventArgs
{
    public SampleEventArgs(string text) { Text = text; }
    public string Text { get; } // readonly
}

public class Publisher
{
    // Declare the delegate (if using non-generic pattern).
    public delegate void SampleEventHandler(object sender, SampleEventArgs e);

    // Declare the event.
    public event SampleEventHandler SampleEvent;

    // Wrap the event in a protected virtual method
    // to enable derived classes to raise the event.
    protected virtual void RaiseSampleEvent()
    {
        // Raise the event in a thread-safe manner using the ?. operator.
        SampleEvent?.Invoke(this, new SampleEventArgs("Hello"));
    }
}

In Grapevine, my implementation currently looks like this (in simplified form, I'm only including relevant stuff here):

public delegate Task RoutingAsyncEventHandler(IHttpContext context);

public class Router : IRouter
{
    public event RoutingAsyncEventHandler BeforeRoutingAsync;

    public virtual async Task<int> RouteAsync(IHttpContext context)
    {
         if (BeforeRoutingAsync != null) await BeforeRoutingAsync.Invoke(context);
    }
}

To the best of my knowledge, there is no built in way to prevent the invocation of the event handlers from executing all of the event handlers. If you are aware of one, please let me know.

You'll notice, in my implementation, that the second parameter to the event handler, the EventArgs, is completely omitted.

If it would be useful, I can create a custom event args class and pass it in on invoke. That custom class can contain a boolean value that indicates whether continued invoking should occur. If you want it to stop executing the handlers, set it to false. HOWEVER, every handler in the chain would need to check and honor that value.

This would mean that the handlers would stop invoking, but, in the case of the Routing events, unless you respond to the request, the context will continue to be routed.

If this is what you are looking for, I can create a discussion with some sample code and we can have a larger discussion about it. What do you think?

[seikosantana]

It doesn't have to be analog of Express JS. I was trying to understand what middlewares actually are, and finding out how to implement and achieve a middleware at least for some custom authentications, and the way explained above should be enough for that purpose (I'm still learning and looking into the source doesn't really help my understanding, yet)

I haven't tested this but in HTTP, isn't responses only sent once, except it is stream? If reponses can only be sent once, doesn't that mean next routes invoked won't be able to write responses again?

If this is what you are looking for, I can create a discussion with some sample code and we can have a larger discussion about it. What do you think?

It might not be necessary to implement that thing if responses can only be sent once i guess. But it might be useful to have middlewares only invoked on specific routes. For example: An auth middleware that is only invoked before any routes, except /login

[scottoffen]

You are correct, you can only send the response once. That is why no more routes are invoked once a response has been sent.