Ask (Quark)us anything!

[giscus[bot]]

Ask (Quark)us anything!

Quarkus: Supersonic Subatomic Java

https://quarkus.io/blog/quarkus-insights-qanda3/

Add your questions below and we will use it to drive next Quarkus Insights episode on January 15th

[marcelmfa]

What are the biggest challenges when migrating a non-quarkus app to Quarkus?
Have you ever experienced problems in configuration, monitoring or even debugging?

[wylswz]

If your infra codes are coupled with framework, for example Spring's auto configuration, you'll have to re-write them using Quarkus extension. And things get more difficult if you want native-image, because most libraries you wrote may require an extension to register something in order to be compiled to native executable. Especially if your app depends on libraries from another team.

[tbkahuna48]

Getting the objects marshaled when an Uni contains an Uni or particularly a Multi when returned asynchronously in an Uni.combine().all():
public Uni getData(String id, String correlationId) {
Uni uniSetup = jokesSetupAdapter.getByIdAsync(id);
Uni uniPunchline = jokesPunchLineAdapter.getById(id);
Uni uniReaction = jokesReactionAdapter.getByIdAsync(id);
return Uni.combine()
.all()
.unis(uniSetup, uniPunchline,uniReaction)
.asTuple()
.onItem()
.transformToUni(tuple -> jokeResponseHandler.buildResponse(tuple));
}
of course we may be doing it wrongly. But when we do the tuple.getItem*() the response is marshaled but not the Uni or Multi in the Response when using readEntity(something.class) to retrieve them.

[tbkahuna48]

Should say when you create a response object using Uni,createFrom()

[tony-in-nz]

Quite a few companies rely on JSF for various reasons:
It's standards complaint
Is stable (companies have been burnt by constant rewrites due to javascript farmeworks fulidity)
A JSF layer does NOT preculde providing restful interfaces for "others" to use as well and allows for rapid prototyping
Strong security (a lot of the page creation is server side)

Although Quarkus is primarly meant as a middleware RESTful microservice component, a job is does admirably, this potentially restricts the use of Quarkus in that it can be used as a "full stack" solution (as well as providing RESTful interfaces). It also allows for a migration path for legacy code that uses JSF.

Using JSF also allows for fast prototyping due to the number of highly mature component libraries.

JSF is about as dead as java... Primefaces has over 1 million downloads of the JSF Primefaces component library a year.

Please support the work done and consider moving this into the extensions:
https://github.com/apache/myfaces/tree/master/extensions/quarkus/

[maxandersen]

Thanks for the question - I'm trying to understand your specific question ?

"Please support the work done and consider moving this into the extensions" do you mean available in code.quarkus and tools? Then that is already there.

[Postremus]

At what point in time is resteasy classic going to be deprecated / removed from quarkus, in favour of resteasy-reactive?

[tony-in-nz]

That's great that it's there. I was looking for JSF and missed it. This is what I am using for multiple projects. Thx

…

On Sat, 15 Jan 2022 at 04:59, Max Rydahl Andersen ***@***.***> wrote: Thanks for the question - I'm trying to understand your specific question ? "Please support the work done and consider moving this into the extensions" do you mean available in code.quarkus and tools? Then that is already there. [image: 2022-01-14_16-56-16] <https://user-images.githubusercontent.com/54129/149545659-ef225002-05f6-4c8a-9d4b-82b1f2adaa9d.png> — Reply to this email directly, view it on GitHub <#22852 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AB6LSISSYFY6H4SRT3OSPVTUWBB73ANCNFSM5L3D755Q> . Triage notifications on the go with GitHub Mobile for iOS <https://apps.apple.com/app/apple-store/id1477376905?ct=notification-email&mt=8&pt=524675> or Android <https://play.google.com/store/apps/details?id=com.github.android&referrer=utm_campaign%3Dnotification-email%26utm_medium%3Demail%26utm_source%3Dgithub>. You are receiving this because you commented.Message ID: ***@***.***>

[sekaijin]

Hello,
Just tried FHIR with Quarkus. FHIR is a standard in the medical world. https://www.hl7.org/fhir/
One (the) reference library in the open source world is HAPI FHIR. https://hapifhir.io/
This one is very full server oriented and not micro service oriented. He makes extensive use of introspection, which is at odds with Quarkus' approach.
So I tried to make a micro service (java only) with FHIR jaxrsserver (the HAPI solution), with Quarkus by simply importing the FHIR structures, and with Quarkus by creating an extension.

I conclude that making an extension is doable but in the end it comes down to redoing in micro service mode what jaxrsserver does in jee mode.
I'm not sure enough of myself to embark on such a project which I think is very vast.
I don't know if it's very timely.

I come here to see how to submit the question to the community to possibly create a quarkus-fhir extension

A+JYT

[tbkahuna48]

Support for FHIR is something we will need as well. Apache Camel has a FHIR component. wonder if quarkus camel provides it as reactive?

[benkard]

Are there any plans to support the Java module system in any way in the future?

(I realize that “support” is very vague. Adding an Automatic-Module-Name to every extension/library and ensuring that there are no split packages would be one way of interpreting it – at least it would enable applications to be modular if they so desire.)

[fage88]

Are there any plans to provide an ARM image for native builds? Though it is technically possible to hack together a native ARM image it is quite cumbersome, so are there any plans to provide utilities to make that easier?

[fage88]

Is there any way to get a better idea of the timeline that a "preview" feature will move out of preview?

At my company we are reluctant to use preview features in production, and it would help out adoption process of these features if we understood better how a feature graduates from preview.

[patrick-radius]

I'm a PHP developer working with Laravel, I'm kicking the tires of Quarkus to add to our toolbox since it seems awesome for some of our services that need a bit more industrial strength microservice features (fault tolerance, messagebus integration etc.).

I dig that you have ActiveRecord within Panache, however compared to Laravels Eloquent I'm still missing so much.
Currently I'm having trouble doing upserts (with UUID primary keyed entities).

In Eloquent this is just an 'MyModel.updateOrCreate(criteria, values)'.
Where criteria are just the predicates and values the new values (and the predicate values and other values get merged when the particular record did not exist yet).

How to do this easily in Quarkus with Panache?

[talios]

Would using JOOQ and the quarkus-jooq extension suit you more? I don't know Eloquent but a quick google seems to show example code that looks like a SQL like language-level DSL.

[patrick-radius]

Would using JOOQ and the quarkus-jooq extension suit you more? I don't know Eloquent but a quick google seems to show example code that looks like a SQL like language-level DSL.

JOOQ seems like a query builder dsl, It could be useful indeed.
Eloquent however is an ActiveRecord implementation, it's loosely inspired by the Ruby On Rails ActiveRecord implementation.

Anyways, my initial question was mostly: what's the easiest way to do upserts of entities (and especially with UUID primary keys)?

[maxandersen]

Assume I understand your question right since panache active record uses managed entitied doing persist will do Update or insert based on id set or not.

[rubencgt]

Hello, I use Quarkus version 2.5.1.Final in a project where we have many legacy databases,
therefore we have to create custom selects from different entities and map them to dtos objects, currently we use hql and we have to create all the entities and manage them in panache if we want to query them by hql.
in Spring there is support for native queries, is Quarkus planning to support native queries?

[maxandersen]

Hibernate which is what Quarkus uses has support for native sql queries. Thus it's available there too.

[knowledgefactory4u]

Hello, Why @ConfigProperties (Deprecated)?

[tbkahuna48]

Quarkus 2.7.5
Documentation and examples say Uni.combine.all should return a composite error exception. However, with 2 exceptions being thrown from 2 clients the first is handled by onFailure before the second client returns. Then when the second client throws the exception it isn't handled and the ugly exception is returned to the UI. What is the right way to do this.
code:
package org.kp.de.ee.mvp.rest.client.service;

import java.util.List;

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import javax.ws.rs.core.Response;

import org.jboss.resteasy.reactive.server.ServerExceptionMapper;
import org.kp.de.ee.db.service.mongodb.MongoDbReactivePunchlineService;
import org.kp.de.ee.mvp.fault.tolerance.JokeReactionAdapter;
import org.kp.de.ee.mvp.fault.tolerance.JokeSetupAdapter;
import org.kp.de.ee.mvp.rest.client.type.JokePunchLine;
import org.kp.de.ee.mvp.rest.client.type.JokeReaction;
import org.kp.de.ee.mvp.rest.client.type.JokeSetup;
import org.kp.de.ee.mvp.rest.response.JokeResponseHandler;

import io.quarkus.runtime.annotations.RegisterForReflection;
import io.smallrye.mutiny.Uni;

@ApplicationScoped
@RegisterForReflection
public class JokesServiceCallManager {

@Inject
MongoDbReactivePunchlineService jokesPunchLineService;

@Inject
JokeResponseHandler jokeResponseHandler;

@Inject
JokeSetupAdapter jokesSetupAdapter;

@Inject
JokeReactionAdapter jokesReactionAdapter;
    

public Uni<Response> getData(String id,String correlationId) {
	Uni<JokeSetup> uniSetup = jokesSetupAdapter.getByIdAsync(id);
	Uni<List<JokePunchLine>> uniPunchline = jokesPunchLineService.getById(id);
	Uni<JokeReaction> uniReaction = jokesReactionAdapter.getByIdAsync(id);
	
	return Uni.combine().all().unis(uniSetup, uniPunchline,uniReaction )
			.asTuple().onItem().transformToUni(tuple -> jokeResponseHandler.createResponseFromTuple(tuple.getItem1().getSetup(), tuple.getItem2().get(0).getPunchline(), tuple.getItem3().getReaction()))
	        .onFailure().invoke(exception -> jokeResponseHandler.buildUniExceptionResponse(exception));
}

@ServerExceptionMapper
public Uni<Response> mapException(Throwable exception) {
	Uni<Response> response = jokeResponseHandler.buildUniExceptionResponse(exception);
 	return response;
}

}

[tbkahuna48]

(removed the @ServerExceptionMapper method) Tried deleting the onFailure and letting FallBack handle errors. Problem there is that it then requires that the adapter return an Uni to match the method signature. Then I end up with an Uni with an entity that is an Uni< JokeSetup> e.g. I can retrieve the Response form the tuple easily enough but then retrieving the JokeSetup from Uni which is itself a UniCompletionStage without blocking is problematic. If I just have the FallBack and adapter return the Uni I still run into the same problem of getting the JokeSetup from the Uni without itblocking.

[tbkahuna48]

second sentence should include *FallBack and adapter retuning an Uni

[mariuszbozek]

Are there any plans to support IMAP/IMAPS in the Mailer extension?

[tbkahuna48]

Anyone know why io.qua.ver.htt.run.QuarkusErrorHandler has suddenly started intercepting exceptions we throw from our clientresponse interceptor>
They were previously handled by the fallbackHandler.

2022-04-21 12:47:39,575 ERROR [io.qua.ver.htt.run.QuarkusErrorHandler] (vert.x-eventloop-thread-13) HTTP Request to /jokes/uni/1 failed, error id: 9cb8f319-f3aa-430c-9d4a-e62040d8c918-1: javax.ws.rs.ProcessingException: org.kp.de.ee.mvp.exception.DataswapException: client dataswap detected!, mismatched headers: x-correlationId
at org.jboss.resteasy.reactive.client.handlers.ClientResponseFilterRestHandler.handle(ClientResponseFilterRestHandler.java:24)
at org.jboss.resteasy.reactive.client.handlers.ClientResponseFilterRestHandler.handle(ClientResponseFilterRestHandler.java:9)
at org.jboss.resteasy.reactive.common.core.AbstractResteasyReactiveContext.run(AbstractResteasyReactiveContext.java:141)
at org.jboss.resteasy.reactive.client.impl.RestClientRequestContext$1.lambda$execute$0(RestClientRequestContext.java:248)
at io.vertx.core.impl.AbstractContext.dispatch(AbstractContext.java:100)
at io.vertx.core.impl.AbstractContext.dispatch(AbstractContext.java:63)
at io.vertx.core.impl.EventLoopContext.lambda$runOnContext$0(EventLoopContext.java:38)
at io.netty.util.concurrent.AbstractEventExecutor.safeExecute(AbstractEventExecutor.java:164)
at io.netty.util.concurrent.SingleThreadEventExecutor.runAllTasks(SingleThreadEventExecutor.java:469)
at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:497)
at io.netty.util.concurrent.SingleThreadEventExecutor$4.run(SingleThreadEventExecutor.java:986)
at io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74)
at io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30)
at java.base/java.lang.Thread.run(Thread.java:829)
Caused by: org.kp.de.ee.mvp.exception.DataswapException: client dataswap detected!, mismatched headers: x-correlationId
at org.kp.de.ee.mvp.rest.interceptor.ClientMessageHandler.applyResponseInstruction(ClientMessageHandler.java:142)
at org.kp.de.ee.mvp.rest.interceptor.ClientMessageHandler.handleResponse(ClientMessageHandler.java:106)
at org.kp.de.ee.mvp.rest.interceptor.InterceptorClient.filter(InterceptorClient.java:64)
at org.kp.de.ee.mvp.rest.interceptor.InterceptorClient_Subclass.filter$$superforward1(InterceptorClient_Subclass.zig:192)
at org.kp.de.ee.mvp.rest.interceptor.InterceptorClient_Subclass$$function$$3.apply(InterceptorClient_Subclass$$function$$3.zig:41)
at io.quarkus.arc.impl.AroundInvokeInvocationContext.proceed(AroundInvokeInvocationContext.java:54)
at io.quarkus.arc.runtime.devconsole.InvocationInterceptor.proceed(InvocationInterceptor.java:62)
at io.quarkus.arc.runtime.devconsole.InvocationInterceptor.monitor(InvocationInterceptor.java:51)
at io.quarkus.arc.runtime.devconsole.InvocationInterceptor_Bean.intercept(InvocationInterceptor_Bean.zig:521)
at io.quarkus.arc.impl.InterceptorInvocation.invoke(InterceptorInvocation.java:41)
at io.quarkus.arc.impl.AroundInvokeInvocationContext.perform(AroundInvokeInvocationContext.java:41)
at io.quarkus.arc.impl.InvocationContexts.performAroundInvoke(InvocationContexts.java:32)
at org.kp.de.ee.mvp.rest.interceptor.InterceptorClient_Subclass.filter(InterceptorClient_Subclass.zig:471)
at org.kp.de.ee.mvp.rest.interceptor.InterceptorClient_ClientProxy.filter(InterceptorClient_ClientProxy.zig:132)
at org.jboss.resteasy.reactive.client.handlers.ClientResponseFilterRestHandler.handle(ClientResponseFilterRestHandler.java:20)
... 13 more
Here is the the FallbackHandler
package org.kp.de.ee.mvp.fault.tolerance;

import javax.inject.Inject;
import javax.ws.rs.core.Response;

import org.eclipse.microprofile.faulttolerance.ExecutionContext;
import org.eclipse.microprofile.faulttolerance.FallbackHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.smallrye.mutiny.Uni;

public class SetupFallBack implements FallbackHandler<Uni> {

private static final Logger LOGGER = LoggerFactory.getLogger(SetupFallBack.class);

@Inject
FallBackErrorHandler fallBackErrorHandler;

 @Override
    public Uni<Response> handle(ExecutionContext executionContext) {
        LOGGER.error(executionContext.getFailure().getLocalizedMessage());
        executionContext.getFailure().printStackTrace();
        
        return Uni.createFrom().item(fallBackErrorHandler.buildResponse(executionContext));
    }

}

Here is the annotated method (adapter is used solely because you can't put @CircuitBreakerName("setup-breaker") on an interface)

package org.kp.de.ee.mvp.fault.tolerance;

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import javax.ws.rs.core.Response;

import org.eclipse.microprofile.faulttolerance.CircuitBreaker;
import org.eclipse.microprofile.faulttolerance.Fallback;
import org.eclipse.microprofile.faulttolerance.Timeout;
import org.eclipse.microprofile.rest.client.inject.RestClient;
import org.kp.de.ee.mvp.rest.client.service.JokesSetupService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.quarkus.runtime.annotations.RegisterForReflection;
import io.smallrye.faulttolerance.api.CircuitBreakerName;
import io.smallrye.mutiny.Uni;

@RegisterForReflection
@ApplicationScoped
public class JokeSetupAdapter {

private static final Logger LOGGER = LoggerFactory.getLogger(JokeSetupAdapter.class);

public JokeSetupAdapter() {
	super();
}

@RestClient
@Inject
JokesSetupService jokesSetupService;

// @Retry
@Timeout(400)
@CircuitBreaker
@CircuitBreakerName("setup-breaker")
@Fallback(SetupFallBack.class)
public Uni<Response> getByIdAsync(String id) {
	LOGGER.debug("JOKE SETUP ADAPTER------------------------  getByIdAsync -----------------");

	return jokesSetupService.getByIdAsync(id);
}

}

here is the interceptor which throws the error because it detects an id mismatch

@Override
public void filter(ClientRequestContext clientRequestContext, ClientResponseContext clientResponseContext)
		throws IOException {
	String clientId = (String) clientRequestContext.getHeaders().getFirst(MvpConstant.CLIENT_ID);
	checkForBadResponse(clientResponseContext, clientId);
	LOGGER.debug(
			"INTERCEPTOR CLIENT RESPONSE %%%%%%%%%%%%%% filter(clientRequestContext,clientResponseContext)  %%%%%%%%%%%%%%% : ");
	LOGGER.debug("------------------------ Response Interceptor MessageUtilCache: "
			+ requestScopedContext.messageUtilCache);
	
	LOGGER.debug("------------------------ ClientId: " + clientId);
	clientMessageHandler.checkForValidResponse(clientResponseContext);
	LOGGER.debug("------------------------ ClientId: " + clientId);
	Map<String, MessageUtilConfiguration> messageUtilConfigurationMap = messageUtilConfigurations
			.messageUtilConfigsMap().get("client");

	MessageUtilConfiguration messageHandlerClientConfig = messageUtilConfigurationMap.get(clientId);
	clientMessageHandler.handleResponse(requestScopedContext, clientRequestContext, clientResponseContext,
			messageHandlerClientConfig, clientId);
}

[tbkahuna48]

The question is why is this QuarkusErrorHandler suddenly intercepting exceptions that used to be intercepted by the SetupFallback