org.jboss.resteasy.spi.HttpResponse Java Examples

/**
 * Set a response cookie.  This solely exists because JAX-RS 1.1 does not support setting HttpOnly cookies
 * @param name
 * @param value
 * @param path
 * @param domain
 * @param comment
 * @param maxAge
 * @param secure
 * @param httpOnly
 * @param sameSite
 */
public static void addCookie(String name, String value, String path, String domain, String comment, int maxAge, boolean secure, boolean httpOnly, SameSiteAttributeValue sameSite) {
    SameSiteAttributeValue sameSiteParam = sameSite;
    // when expiring a cookie we shouldn't set the sameSite attribute; if we set e.g. SameSite=None when expiring a cookie, the new cookie (with maxAge == 0)
    // might be rejected by the browser in some cases resulting in leaving the original cookie untouched; that can even prevent user from accessing their application
    if (maxAge == 0) {
        sameSite = null;
    }

    boolean secure_sameSite = sameSite == SameSiteAttributeValue.NONE || secure; // when SameSite=None, Secure attribute must be set

    HttpResponse response = Resteasy.getContextData(HttpResponse.class);
    StringBuffer cookieBuf = new StringBuffer();
    ServerCookie.appendCookieValue(cookieBuf, 1, name, value, path, domain, comment, maxAge, secure_sameSite, httpOnly, sameSite);
    String cookie = cookieBuf.toString();
    response.getOutputHeaders().add(HttpHeaders.SET_COOKIE, cookie);

    // a workaround for browser in older Apple OSs – browsers ignore cookies with SameSite=None
    if (sameSiteParam == SameSiteAttributeValue.NONE) {
        addCookie(name + LEGACY_COOKIE, value, path, domain, comment, maxAge, secure, httpOnly, null);
    }
}
 

/**
 * Create a new initial access token.
 *
 * @param config
 * @return
 */
@POST
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public ClientInitialAccessPresentation create(ClientInitialAccessCreatePresentation config, @Context final HttpResponse response) {
    auth.clients().requireManage();

    int expiration = config.getExpiration() != null ? config.getExpiration() : 0;
    int count = config.getCount() != null ? config.getCount() : 1;

    ClientInitialAccessModel clientInitialAccessModel = session.realms().createClientInitialAccessModel(realm, expiration, count);

    adminEvent.operation(OperationType.CREATE).resourcePath(session.getContext().getUri(), clientInitialAccessModel.getId()).representation(config).success();

    ClientInitialAccessPresentation rep = wrap(clientInitialAccessModel);

    String token = ClientRegistrationTokenUtils.createInitialAccessToken(session, realm, clientInitialAccessModel);
    rep.setToken(token);

    response.setStatus(Response.Status.CREATED.getStatusCode());
    response.getOutputHeaders().add(HttpHeaders.LOCATION, session.getContext().getUri().getAbsolutePathBuilder().path(clientInitialAccessModel.getId()).build().toString());

    return rep;
}
 

@Override
public Object construct(HttpRequest request, HttpResponse response, boolean unwrapAsync)
        throws Failure, WebApplicationException, ApplicationException {
    if (QuarkusInjectorFactory.CONTAINER == null) {
        return delegate.construct(request, response, unwrapAsync);
    }
    if (factory == null) {
        factory = QuarkusInjectorFactory.CONTAINER.instanceFactory(this.ctor.getDeclaringClass());
    }
    if (factory == null) {
        return delegate.construct(request, response, unwrapAsync);
    }
    return factory.create().get();
}
 

public void addCookie(AuthenticationFlowContext context, String name, String value, String path, String domain, String comment, int maxAge, boolean secure, boolean httpOnly) {
    HttpResponse response = context.getSession().getContext().getContextObject(HttpResponse.class);
    StringBuffer cookieBuf = new StringBuffer();
    ServerCookie.appendCookieValue(cookieBuf, 1, name, value, path, domain, comment, maxAge, secure, httpOnly, null);
    String cookie = cookieBuf.toString();
    response.getOutputHeaders().add(HttpHeaders.SET_COOKIE, cookie);
}
 

private void service(int i, Context context, HttpServerRequest req, HttpServerResponse resp, HttpRequest vertxReq,
		HttpResponse vertxResp, boolean handleNotFound) throws IOException {
	if(i < plugins.size())
		plugins.get(i).aroundRequest(vertxReq, () -> service(i+1, context, req, resp, vertxReq, vertxResp, handleNotFound));
	else
		super.service(context, req, resp, vertxReq, vertxResp, handleNotFound);
}
 

@Override
public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
    Object ret) throws Throwable {
    HttpResponse response = (HttpResponse) allArguments[1];
    AbstractSpan span = ContextManager.activeSpan();
    if (response.getStatus() >= 400) {
        span.errorOccurred();
        Tags.STATUS_CODE.set(span, Integer.toString(response.getStatus()));
    }
    ContextManager.stopSpan();
    return ret;
}
 

@Override
public Object createResource(HttpRequest request, HttpResponse response, ResteasyProviderFactory factory)
{
    Object resource = provider.get();
    contextPropertyInjector.inject(request, response, resource);
    return resource;
}
 

@Override
public Object createResource(final HttpRequest request,
                             final HttpResponse response,
                             final ResteasyProviderFactory factory)
{
  final Object resource = entry.getValue();
  propertyInjector.inject(request, response, resource);
  return resource;
}
 

public void requestFinished(HttpRequest request, HttpResponse response,
                            Object resource) {
}
 

public static void addP3PHeader() {
    HttpResponse response = Resteasy.getContextData(HttpResponse.class);
    response.getOutputHeaders().putSingle("P3P", "CP=\"This is not a P3P policy!\"");
}
 

public static void noBackButtonCacheControlHeader() {
    HttpResponse response = Resteasy.getContextData(HttpResponse.class);
    response.getOutputHeaders().putSingle("Cache-Control", "no-store, must-revalidate, max-age=0");
}
 

public void build(HttpResponse response) {
    String origin = request.getHttpHeaders().getRequestHeaders().getFirst(ORIGIN_HEADER);
    if (origin == null) {
        logger.trace("No origin header ignoring");
        return;
    }

    if (!preflight && (allowedOrigins == null || (!allowedOrigins.contains(origin) && !allowedOrigins.contains(ACCESS_CONTROL_ALLOW_ORIGIN_WILDCARD)))) {
        if (logger.isDebugEnabled()) {
            logger.debugv("Invalid CORS request: origin {0} not in allowed origins {1}", origin, allowedOrigins);
        }
        return;
    }

    if (allowedOrigins.contains(ACCESS_CONTROL_ALLOW_ORIGIN_WILDCARD)) {
        response.getOutputHeaders().add(ACCESS_CONTROL_ALLOW_ORIGIN, ACCESS_CONTROL_ALLOW_ORIGIN_WILDCARD);
    } else {
        response.getOutputHeaders().add(ACCESS_CONTROL_ALLOW_ORIGIN, origin);
    }

    if (preflight) {
        if (allowedMethods != null) {
            response.getOutputHeaders().add(ACCESS_CONTROL_ALLOW_METHODS, CollectionUtil.join(allowedMethods));
        } else {
            response.getOutputHeaders().add(ACCESS_CONTROL_ALLOW_METHODS, DEFAULT_ALLOW_METHODS);
        }
    }

    if (!preflight && exposedHeaders != null) {
        response.getOutputHeaders().add(ACCESS_CONTROL_EXPOSE_HEADERS, CollectionUtil.join(exposedHeaders));
    }

    response.getOutputHeaders().add(ACCESS_CONTROL_ALLOW_CREDENTIALS, Boolean.toString(auth));

    if (preflight) {
        if (auth) {
            response.getOutputHeaders().add(ACCESS_CONTROL_ALLOW_HEADERS, String.format("%s, %s", DEFAULT_ALLOW_HEADERS, AUTHORIZATION_HEADER));
        } else {
            response.getOutputHeaders().add(ACCESS_CONTROL_ALLOW_HEADERS, DEFAULT_ALLOW_HEADERS);
        }
    }

    if (preflight) {
        response.getOutputHeaders().add(ACCESS_CONTROL_MAX_AGE, DEFAULT_MAX_AGE);
    }

    logger.debug("Added CORS headers to response");
}
 

public void requestFinished(HttpRequest request, HttpResponse response,
                            Object resource) {
}
 

public Object createResource(HttpRequest request, HttpResponse response,
                             ResteasyProviderFactory factory) {
    return resourceInstance;
}
 

@Override
public void requestFinished(HttpRequest request, HttpResponse response, Object resource)
{ }
 

@Override
public void requestFinished(final HttpRequest request, final HttpResponse response, final Object resource) {
  // ignore
}
 

@Override
public Object inject(HttpRequest request, HttpResponse response) {
    return provider.apply(new RestEasyRequestContext(providerFactory, request));
}
 

@Override
public Object createResource(HttpRequest request, HttpResponse response,
                             ResteasyProviderFactory factory) {
    return resourceInstance;
}
 

public Object createResource(HttpRequest request, HttpResponse response,
                             ResteasyProviderFactory factory) {
    return resourceInstance;
}
 

public void requestFinished(HttpRequest request, HttpResponse response,
                            Object resource) {
}
 

public Object createResource(HttpRequest request, HttpResponse response,
                             ResteasyProviderFactory factory) {
    return resourceInstance;
}
 

public void requestFinished(HttpRequest request, HttpResponse response,
                            Object resource) {
}
 

public Object createResource(HttpRequest request, HttpResponse response,
                             ResteasyProviderFactory factory) {
    return resourceInstance;
}
 

@Override
public void service(Context context, HttpServerRequest req, HttpServerResponse resp, HttpRequest vertxReq,
		HttpResponse vertxResp, boolean handleNotFound) throws IOException {
	service(0, context, req, resp, vertxReq, vertxResp, handleNotFound);
}
 

@Override
public Object inject(HttpRequest request, HttpResponse response) {
    return null;
}
 

@Override
public void invoke(HttpRequest request, HttpResponse response, ResourceInvoker invoker) {
    // 可以执行一下逻辑，例如切换ClassLoader等
    super.invoke(request, response, invoker);
}
 

@Override
public Object injectableArguments(HttpRequest request, HttpResponse response, boolean unwrapAsync)
        throws Failure {
    return this.delegate.injectableArguments(request, response, unwrapAsync);
}
 

@Override
public CompletionStage<Void> inject(HttpRequest request, HttpResponse response, Object target, boolean unwrapAsync)
        throws Failure, WebApplicationException, ApplicationException {
    return delegate.inject(request, response, PROXY_UNWRAPPER.apply(target), unwrapAsync);
}
 

@GET
public void setCookies(@Context HttpResponse response) {
    response.getOutputHeaders().add(HttpHeaders.SET_COOKIE, "c1=c1");
    response.getOutputHeaders().add(HttpHeaders.SET_COOKIE, "c2=c2");
    response.getOutputHeaders().add(HttpHeaders.SET_COOKIE, "c3=c3");
}
 

@Override
public void requestFinished(HttpRequest request, HttpResponse response,
                            Object resource) {
}