Implement a 'forward'

[i1619khz]

How can I implement a 'forward' method in Armeria similar to the one in Servlet, to internally forward a request to another handler or route within the same request context?

[i1619khz]

Similar to the API provided by the servlet

HttpServletResponse response = ....
request.getRequestDispatcher(path).forward(request, response);

[jrhee17]

Hi, I don't think there is an analogous feature in Armeria as it doesn't fully support all servlet features.

1. Perhaps if your method accepts an HttpRequest, you can call the other service manually.

2. Another option is to use TomcatService which uses Armeria internally.
   e.g.

Tomcat tomcat = new Tomcat();
HttpServlet servlet = new MyHttpServlet();
Context context = tomcatWithWebApp.addWebapp("", ..);
Tomcat.addServlet(context, "forward", servlet);

...

Server.builder()
      .serviceUnder("/path", TomcatService.of(tomcat))

[i1619khz]

Perhaps if your method accepts an HttpRequest, you can call the other service manually.

What should I do to request this, use httpclient directly to request it? Servlets don't seem to work that way

[jrhee17]

Perhaps if your method accepts an HttpRequest, you can call the other service manually.

I was literally imagining delegating the call to the service layer

static class SimpleClass {
    static HttpResponse methodA(ServiceRequestContext ctx, HttpRequest req) {
        if (req.path().equals("/")) {
            return methodB(ctx, req);
        }
        // do something
        return HttpResponse.of(200);
    }

    static HttpResponse methodB(ServiceRequestContext ctx, HttpRequest req) {
        // do something
        return HttpResponse.of(200);
    }
}

Server.builder()
      // delegate forwarding to the service layer
      .service("/v1", (ctx, req) -> SimpleClass.methodA(ctx, req))

I think some other possible things are:

Server.builder()
      // return a redirect call
      .service("/v2", (ctx, req) -> HttpResponse.ofRedirect("/different/location"))
      // manually proxy the call
      .service("/v3", (ctx, req) -> WebClient.of("some uri").execute(req))

If the above solutions don't work for you, we probably need to implement a new feature.
It might be helpful if you can explain your use case a little.
For instance, do you expect that decorators are rerun when forwarded? Armeria has no notion of a Filter like servlets do.

If you are just looking for an injection point where you can rewrite the path, it may be relatively easy to implement.

Server.builder()
      .uriTransformer(previousUri -> {
          if (previousUri.startsWith("/v1")) {
              previousUri.replaceAll("v1", "v2");
          }
          return previousUri;
      });

[i1619khz]

hi! @jrhee17

It would be better if forward could be offered on ServiceRequestContext, it is mainly because of other framework integration, some scenarios need to call operations like 'forward', 'redirect' and other operations. Need a context class that provides a variety of functions for flexibility.

like this https://github.com/lets-blade/blade There is a RouterContext providing function flexible operation, Currently, the functions provided by armeria are not straightforward enough.

In many scenarios, it is hoped that the request and response objects can be directly obtained, and then the response can be modified arbitrarily.

like this code

@Override
public Object forward(String path) {
	try {
		HttpServletResponse response = (HttpServletResponse)SaManager.getSaTokenContextOrSecond().getResponse().getSource();
		request.getRequestDispatcher(path).forward(request, response);
		return null;
	} catch (ServletException | IOException e) {
		throw new SaTokenException(e).setCode(SaServletErrorCode.CODE_20001);
	}
}

I wish armeria could be something like this

@Override
public Object forward(String path) {
	try {
                var request = ServiceRequestContext.current().request();
                var response = ServiceRequestContext.current().response();
		return ServiceRequestContext.of(HttpRequest(HttpMethod.GET, path)).forward(request, response);
	} catch (ServletException | IOException e) {
		throw new SaTokenException(e).setCode(SaServletErrorCode.CODE_20001);
	}
}

I'm not going to use anything servlet related in my project

[jrhee17]

In many scenarios, it is hoped that the request and response objects can be directly obtained, and then the response can be modified arbitrarily.

The response in Armeria isn't pre-determined and users are free to return their own HttpResponse.
However, I don't think this is the reason why it is difficult to implement a forwarding functionality.

If we do decide to implement a forward functionality it probably won't be trivial and require quite a few changes. So we would need a reason (use-case) that can't be covered with the above workarounds. (and we can decide whether/how to invest our resources which frankly isn't a lot 😄 )

[i1619khz]

Perhaps if your method accepts an HttpRequest, you can call the other service manually.

I was literally imagining delegating the call to the service layer

static class SimpleClass {
    static HttpResponse methodA(ServiceRequestContext ctx, HttpRequest req) {
        if (req.path().equals("/")) {
            return methodB(ctx, req);
        }
        // do something
        return HttpResponse.of(200);
    }

    static HttpResponse methodB(ServiceRequestContext ctx, HttpRequest req) {
        // do something
        return HttpResponse.of(200);
    }
}

Server.builder()
      // delegate forwarding to the service layer
      .service("/v1", (ctx, req) -> SimpleClass.methodA(ctx, req))

I think some other possible things are:

Server.builder()
      // return a redirect call
      .service("/v2", (ctx, req) -> HttpResponse.ofRedirect("/different/location"))
      // manually proxy the call
      .service("/v3", (ctx, req) -> WebClient.of("some uri").execute(req))

If the above solutions don't work for you, we probably need to implement a new feature. It might be helpful if you can explain your use case a little. For instance, do you expect that decorators are rerun when forwarded? Armeria has no notion of a Filter like servlets do.

If you are just looking for an injection point where you can rewrite the path, it may be relatively easy to implement.

Server.builder()
      .uriTransformer(previousUri -> {
          if (previousUri.startsWith("/v1")) {
              previousUri.replaceAll("v1", "v2");
          }
          return previousUri;
      });

That's a good idea, but it doesn't really fit my scenario