You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tomee.apache.org by db...@apache.org on 2021/04/30 09:00:15 UTC

[tomee-jakarta] branch master updated (e5db5c0 -> 6a96152)

This is an automated email from the ASF dual-hosted git repository.

dblevins pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/tomee-jakarta.git.


    from e5db5c0  Don't change or rename javax.rmi.PortableRemoteObject package for the moment
     new 7d50e1d  TOMEE-3164 jaxrs.jaxrs21.ee.priority paramConverterPriorityTest
     new 33415ca  TOMEE-3187 jaxrs.spec.provider.standardnotnull clientDataSourceProviderTest
     new 6a96152  Merge branch 'master' of github.com:apache/tomee-jakarta

The 3 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 .../org/apache/cxf/jaxrs/impl/ResponseImpl.java    | 629 +++++++++++++++++++++
 .../apache/cxf/jaxrs/provider/ProviderFactory.java |  86 ++-
 .../org/apache/cxf/jaxrs/utils/JAXRSUtils.java     |  69 +--
 3 files changed, 736 insertions(+), 48 deletions(-)
 create mode 100644 transform/src/patch/java/org/apache/cxf/jaxrs/impl/ResponseImpl.java

[tomee-jakarta] 02/03: TOMEE-3187 jaxrs.spec.provider.standardnotnull clientDataSourceProviderTest

Posted by db...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

dblevins pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/tomee-jakarta.git

commit 33415ca9cef1054d21f483f111a1adba6f7029b8
Author: David Blevins <da...@gmail.com>
AuthorDate: Fri Apr 30 01:56:37 2021 -0700

    TOMEE-3187 jaxrs.spec.provider.standardnotnull clientDataSourceProviderTest
---
 .../org/apache/cxf/jaxrs/impl/ResponseImpl.java    | 629 +++++++++++++++++++++
 .../org/apache/cxf/jaxrs/utils/JAXRSUtils.java     |  69 +--
 2 files changed, 664 insertions(+), 34 deletions(-)

diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/impl/ResponseImpl.java b/transform/src/patch/java/org/apache/cxf/jaxrs/impl/ResponseImpl.java
new file mode 100644
index 0000000..e240f50
--- /dev/null
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/impl/ResponseImpl.java
@@ -0,0 +1,629 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cxf.jaxrs.impl;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PushbackInputStream;
+import java.io.Reader;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+import javax.ws.rs.ProcessingException;
+import javax.ws.rs.client.ResponseProcessingException;
+import javax.ws.rs.core.EntityTag;
+import javax.ws.rs.core.GenericType;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.Link;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.NewCookie;
+import javax.ws.rs.core.NoContentException;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status.Family;
+import javax.ws.rs.ext.ReaderInterceptor;
+import javax.ws.rs.ext.RuntimeDelegate.HeaderDelegate;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.transform.Source;
+
+import org.apache.cxf.helpers.IOUtils;
+import org.apache.cxf.io.ReaderInputStream;
+import org.apache.cxf.jaxrs.provider.ProviderFactory;
+import org.apache.cxf.jaxrs.utils.HttpUtils;
+import org.apache.cxf.jaxrs.utils.InjectionUtils;
+import org.apache.cxf.jaxrs.utils.JAXRSUtils;
+import org.apache.cxf.message.Message;
+import org.apache.cxf.message.MessageUtils;
+
+public final class ResponseImpl extends Response {
+
+    private static final Pattern LINK_DELIMITER = Pattern.compile(",\\s*(?=\\<|$)");
+
+    private StatusType status;
+    private Object entity;
+    private Annotation[] entityAnnotations;
+    private MultivaluedMap<String, Object> metadata;
+
+    private Message outMessage;
+    private boolean entityClosed;
+    private boolean entityBufferred;
+    private Object lastEntity;
+
+    ResponseImpl(int statusCode) {
+        this.status = createStatusType(statusCode, null);
+    }
+
+    ResponseImpl(int statusCode, Object entity) {
+        this(statusCode);
+        this.entity = entity;
+    }
+
+    ResponseImpl(int statusCode, Object entity, String reasonPhrase) {
+        this.status = createStatusType(statusCode, reasonPhrase);
+        this.entity = entity;
+    }
+
+    public void addMetadata(MultivaluedMap<String, Object> meta) {
+        this.metadata = meta;
+    }
+
+    public void setStatus(int statusCode) {
+        this.status = createStatusType(statusCode, null);
+    }
+
+    public void setStatus(int statusCode, String reasonPhrase) {
+        this.status = createStatusType(statusCode, reasonPhrase);
+    }
+
+    public void setEntity(Object e, Annotation[] anns) {
+        this.entity = e;
+        this.entityAnnotations = anns;
+    }
+
+    public void setEntityAnnotations(Annotation[] anns) {
+        this.entityAnnotations = anns;
+    }
+
+    public Annotation[] getEntityAnnotations() {
+        return entityAnnotations;
+    }
+
+    public void setOutMessage(Message message) {
+        this.outMessage = message;
+    }
+
+    public Message getOutMessage() {
+        return this.outMessage;
+    }
+
+    @Override
+    public int getStatus() {
+        return status.getStatusCode();
+    }
+
+    @Override
+    public StatusType getStatusInfo() {
+        return status;
+    }
+
+    public Object getActualEntity() {
+        checkEntityIsClosed();
+        return lastEntity != null ? lastEntity : entity;
+    }
+
+    @Override
+    public Object getEntity() {
+        return InjectionUtils.getEntity(getActualEntity());
+    }
+
+    @Override
+    public boolean hasEntity() {
+        // per spec, need to check if the stream exists and if it has data.
+        Object actualEntity = getActualEntity();
+        if (actualEntity == null) {
+            return false;
+        } else if (actualEntity instanceof InputStream) {
+            final InputStream is = (InputStream) actualEntity;
+            try {
+                if (is.markSupported()) {
+                    is.mark(1);
+                    int i = is.read();
+                    is.reset();
+                    return i != -1;
+                } else {
+                    try {
+                        if (is.available() > 0) {
+                            return true;
+                        }
+                    } catch (IOException ioe) {
+                        //Do nothing
+                    }
+                    int b = is.read();
+                    if (b == -1) {
+                        return false;
+                    }
+                    PushbackInputStream pbis;
+                    if (is instanceof PushbackInputStream) {
+                        pbis = (PushbackInputStream) is;
+                    } else {
+                        pbis = new PushbackInputStream(is, 1);
+                        if (lastEntity != null) {
+                            lastEntity = pbis;
+                        } else {
+                            entity = pbis;
+                        }
+                    }
+                    pbis.unread(b);
+                    return true;
+                }
+            } catch (IOException ex) {
+                throw new ProcessingException(ex);
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public MultivaluedMap<String, Object> getMetadata() {
+        return getHeaders();
+    }
+
+    @Override
+    public MultivaluedMap<String, Object> getHeaders() {
+        return metadata;
+    }
+
+    @Override
+    public MultivaluedMap<String, String> getStringHeaders() {
+        MetadataMap<String, String> headers = new MetadataMap<>(metadata.size());
+        for (Map.Entry<String, List<Object>> entry : metadata.entrySet()) {
+            String headerName = entry.getKey();
+            headers.put(headerName, toListOfStrings(entry.getValue()));
+        }
+        return headers;
+    }
+
+    @Override
+    public String getHeaderString(String header) {
+        List<Object> methodValues = metadata.get(header);
+        return HttpUtils.getHeaderString(toListOfStrings(methodValues));
+    }
+
+    // This conversion is needed as some values may not be Strings
+    private List<String> toListOfStrings(List<Object> values) {
+        if (values == null) {
+            return null;
+        }
+        List<String> stringValues = new ArrayList<>(values.size());
+        HeaderDelegate<Object> hd = HttpUtils.getHeaderDelegate(values.get(0));
+        for (Object value : values) {
+            String actualValue = hd == null ? value.toString() : hd.toString(value);
+            stringValues.add(actualValue);
+        }
+        return stringValues;
+    }
+
+    @Override
+    public Set<String> getAllowedMethods() {
+        List<Object> methodValues = metadata.get(HttpHeaders.ALLOW);
+        if (methodValues == null) {
+            return Collections.emptySet();
+        }
+        Set<String> methods = new HashSet<>();
+        for (Object o : methodValues) {
+            methods.add(o.toString());
+        }
+        return methods;
+    }
+
+    @Override
+    public Map<String, NewCookie> getCookies() {
+        List<Object> cookieValues = metadata.get(HttpHeaders.SET_COOKIE);
+        if (cookieValues == null) {
+            return Collections.emptyMap();
+        }
+        Map<String, NewCookie> cookies = new HashMap<>();
+        for (Object o : cookieValues) {
+            NewCookie newCookie = NewCookie.valueOf(o.toString());
+            cookies.put(newCookie.getName(), newCookie);
+        }
+        return cookies;
+    }
+
+    @Override
+    public Date getDate() {
+        return doGetDate(HttpHeaders.DATE);
+    }
+
+    private Date doGetDate(String dateHeader) {
+        Object value = metadata.getFirst(dateHeader);
+        return value == null || value instanceof Date ? (Date)value
+            : HttpUtils.getHttpDate(value.toString());
+    }
+
+    @Override
+    public EntityTag getEntityTag() {
+        Object header = metadata.getFirst(HttpHeaders.ETAG);
+        return header == null || header instanceof EntityTag ? (EntityTag)header
+            : EntityTag.valueOf(header.toString());
+    }
+
+    @Override
+    public Locale getLanguage() {
+        Object header = metadata.getFirst(HttpHeaders.CONTENT_LANGUAGE);
+        return header == null || header instanceof Locale ? (Locale)header
+            : HttpUtils.getLocale(header.toString());
+    }
+
+    @Override
+    public Date getLastModified() {
+        return doGetDate(HttpHeaders.LAST_MODIFIED);
+    }
+
+    @Override
+    public int getLength() {
+        Object header = metadata.getFirst(HttpHeaders.CONTENT_LENGTH);
+        return HttpUtils.getContentLength(header == null ? null : header.toString());
+    }
+
+    @Override
+    public URI getLocation() {
+        Object header = metadata.getFirst(HttpHeaders.LOCATION);
+        return header == null || header instanceof URI ? (URI)header
+            : URI.create(header.toString());
+    }
+
+    @Override
+    public MediaType getMediaType() {
+        Object header = metadata.getFirst(HttpHeaders.CONTENT_TYPE);
+        return header == null || header instanceof MediaType ? (MediaType)header
+            : (MediaType)JAXRSUtils.toMediaType(header.toString());
+    }
+
+    @Override
+    public boolean hasLink(String relation) {
+        List<Object> linkValues = metadata.get(HttpHeaders.LINK);
+        if (linkValues != null) {
+            for (Object o : linkValues) {
+                if (o instanceof Link && relation.equals(((Link)o).getRel())) {
+                    return true;
+                }
+
+                String[] links = LINK_DELIMITER.split(o.toString());
+                for (String splitLink : links) {
+                    Link link = Link.valueOf(splitLink);
+                    if (relation.equals(link.getRel())) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public Link getLink(String relation) {
+        Set<Link> links = getAllLinks();
+        for (Link link : links) {
+            if (link.getRel() != null && link.getRel().equals(relation)) {
+                return link;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public Link.Builder getLinkBuilder(String relation) {
+        Link link = getLink(relation);
+        return link == null ? null : Link.fromLink(link);
+    }
+
+    @Override
+    public Set<Link> getLinks() {
+        return new HashSet<>(getAllLinks());
+    }
+
+    private Set<Link> getAllLinks() {
+        List<Object> linkValues = metadata.get(HttpHeaders.LINK);
+        if (linkValues == null) {
+            return Collections.emptySet();
+        }
+        Set<Link> links = new LinkedHashSet<>();
+        for (Object o : linkValues) {
+            List<Link> parsedLinks = parseLink(o);
+
+            links.addAll(parsedLinks);
+        }
+        return links;
+    }
+
+    private Link makeAbsoluteLink(Link link) {
+        if (!link.getUri().isAbsolute()) {
+            URI requestURI = URI.create((String)outMessage.get(Message.REQUEST_URI));
+            link = Link.fromLink(link).baseUri(requestURI).build();
+        }
+
+        return link;
+    }
+
+    private List<Link> parseLink(Object o) {
+        if (o instanceof Link) {
+            return Collections.singletonList(makeAbsoluteLink((Link) o));
+        }
+
+        List<Link> links = new ArrayList<>();
+        String[] linkArray = LINK_DELIMITER.split(o.toString());
+
+        for (String textLink : linkArray) {
+            Link link = Link.valueOf(textLink);
+            links.add(makeAbsoluteLink(link));
+        }
+
+        return Collections.unmodifiableList(links);
+    }
+
+    @Override
+    public <T> T readEntity(Class<T> cls) throws ProcessingException, IllegalStateException {
+        return readEntity(cls, new Annotation[]{});
+    }
+
+    @Override
+    public <T> T readEntity(GenericType<T> genType) throws ProcessingException, IllegalStateException {
+        return readEntity(genType, new Annotation[]{});
+    }
+
+    @Override
+    public <T> T readEntity(Class<T> cls, Annotation[] anns) throws ProcessingException, IllegalStateException {
+        return doReadEntity(cls, cls, anns);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> T readEntity(GenericType<T> genType, Annotation[] anns)
+        throws ProcessingException, IllegalStateException {
+        return doReadEntity((Class<T>) genType.getRawType(),
+                            genType.getType(), anns);
+    }
+
+    public <T> T doReadEntity(Class<T> cls, Type t, Annotation[] anns)
+        throws ProcessingException, IllegalStateException {
+
+        checkEntityIsClosed();
+        //according to javadoc, should close when is not buffered.
+        boolean shouldClose = !entityBufferred && !JAXRSUtils.isStreamingOutType(cls);
+
+        if (lastEntity != null && cls.isAssignableFrom(lastEntity.getClass())
+            && !(lastEntity instanceof InputStream)) {
+            return cls.cast(lastEntity);
+        }
+
+        MediaType mediaType = getMediaType();
+        if (mediaType == null) {
+            mediaType = MediaType.WILDCARD_TYPE;
+        }
+
+        // the stream is available if entity is IS or
+        // message contains XMLStreamReader or Reader
+        boolean entityStreamAvailable = entityStreamAvailable();
+        InputStream entityStream = null;
+        if (!entityStreamAvailable) {
+            // try create a stream if the entity is String or Number
+            entityStream = convertEntityToStreamIfPossible();
+            entityStreamAvailable = entityStream != null;
+        } else if (entity instanceof InputStream) {
+            entityStream = InputStream.class.cast(entity);
+        } else {
+            Message inMessage = getResponseMessage();
+            Reader reader = inMessage.getContent(Reader.class);
+            if (reader != null) {
+                entityStream = InputStream.class.cast(new ReaderInputStream(reader));
+            }
+        }
+
+        // we need to check for readers even if no IS is set - the readers may still do it
+        List<ReaderInterceptor> readers = outMessage == null ? null : ProviderFactory.getInstance(outMessage)
+            .createMessageBodyReaderInterceptor(cls, t, anns, mediaType, outMessage, entityStreamAvailable, null);
+
+        if (readers != null) {
+            try {
+                if (entityBufferred) {
+                    InputStream.class.cast(entity).reset();
+                }
+
+                Message responseMessage = getResponseMessage();
+                responseMessage.put(Message.PROTOCOL_HEADERS, getHeaders());
+
+                lastEntity = JAXRSUtils.readFromMessageBodyReader(readers, cls, t,
+                                                                  anns,
+                                                                  entityStream,
+                                                                  mediaType,
+                                                                  responseMessage);
+                // close the entity after readEntity is called.
+                T tCastLastEntity = castLastEntity();
+                shouldClose = shouldClose && !(tCastLastEntity instanceof AutoCloseable)
+                    && !(tCastLastEntity instanceof Source);
+                if (shouldClose) {
+                    close();
+                }
+                return tCastLastEntity;
+            } catch (NoContentException ex) {
+                //when content is empty, return null instead of throw exception to pass TCK
+                //check if basic type. Basic type throw exception, else return null.
+                if (isBasicType(cls)) {
+                    autoClose(cls, true);
+                    reportMessageHandlerProblem("MSG_READER_PROBLEM", cls, mediaType, ex);
+                } else {
+                    if (shouldClose) {
+                        close();
+                    }
+                    return null;
+                }
+            } catch (Exception ex) {
+                autoClose(cls, true);
+                reportMessageHandlerProblem("MSG_READER_PROBLEM", cls, mediaType, ex);
+            } finally {
+                ProviderFactory pf = ProviderFactory.getInstance(outMessage);
+                if (pf != null) {
+                    pf.clearThreadLocalProxies();
+                }
+            }
+        } else if (entity != null && cls.isAssignableFrom(entity.getClass())) {
+            lastEntity = entity;
+            return castLastEntity();
+        } else if (entityStreamAvailable) {
+            reportMessageHandlerProblem("NO_MSG_READER", cls, mediaType, null);
+        }
+
+        throw new IllegalStateException("The entity is not backed by an input stream, entity class is : "
+            + (entity != null ? entity.getClass().getName() : cls.getName()));
+
+    }
+
+    @SuppressWarnings("unchecked")
+    private <T> T castLastEntity() {
+        return (T)lastEntity;
+    }
+
+    public InputStream convertEntityToStreamIfPossible() {
+        String stringEntity = null;
+        if (entity instanceof String || entity instanceof Number) {
+            stringEntity = entity.toString();
+        }
+        if (stringEntity != null) {
+            try {
+                return new ByteArrayInputStream(stringEntity.getBytes(StandardCharsets.UTF_8));
+            } catch (Exception ex) {
+                throw new ProcessingException(ex);
+            }
+        }
+        return null;
+    }
+
+    private boolean entityStreamAvailable() {
+        if (entity == null) {
+            Message inMessage = getResponseMessage();
+            return inMessage != null && (inMessage.getContent(XMLStreamReader.class) != null
+                || inMessage.getContent(Reader.class) != null);
+        }
+        return entity instanceof InputStream;
+    }
+
+    private Message getResponseMessage() {
+        Message responseMessage = outMessage.getExchange().getInMessage();
+        if (responseMessage == null) {
+            responseMessage = outMessage.getExchange().getInFaultMessage();
+        }
+        return responseMessage;
+    }
+
+    private void reportMessageHandlerProblem(String name, Class<?> cls, MediaType ct, Throwable cause) {
+        String errorMessage = JAXRSUtils.logMessageHandlerProblem(name, cls, ct);
+        throw new ResponseProcessingException(this, errorMessage, cause);
+    }
+
+    protected void autoClose(Class<?> cls, boolean exception) {
+        if (!entityBufferred && !JAXRSUtils.isStreamingOutType(cls)
+            && (exception || MessageUtils.getContextualBoolean(outMessage, "response.stream.auto.close"))) {
+            close();
+        }
+    }
+
+    @Override
+    public boolean bufferEntity() throws ProcessingException {
+        checkEntityIsClosed();
+        if (!entityBufferred && entity instanceof InputStream) {
+            try {
+                InputStream oldEntity = (InputStream)entity;
+                entity = IOUtils.loadIntoBAIS(oldEntity);
+                oldEntity.close();
+                entityBufferred = true;
+            } catch (IOException ex) {
+                throw new ResponseProcessingException(this, ex);
+            }
+        }
+        return entityBufferred;
+    }
+
+    @Override
+    public void close() throws ProcessingException {
+        if (!entityClosed) {
+            if (!entityBufferred && entity instanceof InputStream) {
+                try {
+                    ((InputStream)entity).close();
+                } catch (IOException ex) {
+                    throw new ResponseProcessingException(this, ex);
+                }
+            }
+            entity = null;
+            entityClosed = true;
+        }
+
+    }
+
+    private void checkEntityIsClosed() {
+        if (entityClosed) {
+            throw new IllegalStateException("Entity is not available");
+        }
+    }
+
+    private Response.StatusType createStatusType(int statusCode, String reasonPhrase) {
+        return new Response.StatusType() {
+
+            @Override
+            public Family getFamily() {
+                return Response.Status.Family.familyOf(statusCode);
+            }
+
+            @Override
+            public String getReasonPhrase() {
+                if (reasonPhrase != null) {
+                    return reasonPhrase;
+                }
+                Response.Status statusEnum = Response.Status.fromStatusCode(statusCode);
+                return statusEnum != null ? statusEnum.getReasonPhrase() : "";
+            }
+
+            @Override
+            public int getStatusCode() {
+                return statusCode;
+            }
+
+        };
+    }
+
+    private static boolean isBasicType(Class<?> type) {
+        return type.isPrimitive() || Number.class.isAssignableFrom(type) || Boolean.class.isAssignableFrom(type)
+            || Character.class.isAssignableFrom(type);
+    }
+}
\ No newline at end of file
diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/utils/JAXRSUtils.java b/transform/src/patch/java/org/apache/cxf/jaxrs/utils/JAXRSUtils.java
index 0254368..4cf99ff 100644
--- a/transform/src/patch/java/org/apache/cxf/jaxrs/utils/JAXRSUtils.java
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/utils/JAXRSUtils.java
@@ -47,39 +47,40 @@ import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.util.stream.Collectors;
 
-import jakarta.ws.rs.ClientErrorException;
-import jakarta.ws.rs.Consumes;
-import jakarta.ws.rs.HttpMethod;
-import jakarta.ws.rs.Produces;
-import jakarta.ws.rs.WebApplicationException;
-import jakarta.ws.rs.container.AsyncResponse;
-import jakarta.ws.rs.container.ContainerRequestContext;
-import jakarta.ws.rs.container.ContainerRequestFilter;
-import jakarta.ws.rs.container.ContainerResponseContext;
-import jakarta.ws.rs.container.ContainerResponseFilter;
-import jakarta.ws.rs.container.ResourceContext;
-import jakarta.ws.rs.container.ResourceInfo;
-import jakarta.ws.rs.core.Application;
-import jakarta.ws.rs.core.Configuration;
-import jakarta.ws.rs.core.Cookie;
-import jakarta.ws.rs.core.HttpHeaders;
-import jakarta.ws.rs.core.MediaType;
-import jakarta.ws.rs.core.MultivaluedMap;
-import jakarta.ws.rs.core.PathSegment;
-import jakarta.ws.rs.core.Request;
-import jakarta.ws.rs.core.Response;
-import jakarta.ws.rs.core.Response.ResponseBuilder;
-import jakarta.ws.rs.core.SecurityContext;
-import jakarta.ws.rs.core.StreamingOutput;
-import jakarta.ws.rs.core.UriInfo;
-import jakarta.ws.rs.ext.ContextResolver;
-import jakarta.ws.rs.ext.MessageBodyReader;
-import jakarta.ws.rs.ext.MessageBodyWriter;
-import jakarta.ws.rs.ext.Providers;
-import jakarta.ws.rs.ext.ReaderInterceptor;
-import jakarta.ws.rs.ext.ReaderInterceptorContext;
-import jakarta.ws.rs.ext.WriterInterceptor;
-import jakarta.ws.rs.ext.WriterInterceptorContext;
+import javax.activation.DataSource;
+import javax.ws.rs.ClientErrorException;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.HttpMethod;
+import javax.ws.rs.Produces;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.container.AsyncResponse;
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.container.ContainerRequestFilter;
+import javax.ws.rs.container.ContainerResponseContext;
+import javax.ws.rs.container.ContainerResponseFilter;
+import javax.ws.rs.container.ResourceContext;
+import javax.ws.rs.container.ResourceInfo;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.Configuration;
+import javax.ws.rs.core.Cookie;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.PathSegment;
+import javax.ws.rs.core.Request;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.ResponseBuilder;
+import javax.ws.rs.core.SecurityContext;
+import javax.ws.rs.core.StreamingOutput;
+import javax.ws.rs.core.UriInfo;
+import javax.ws.rs.ext.ContextResolver;
+import javax.ws.rs.ext.MessageBodyReader;
+import javax.ws.rs.ext.MessageBodyWriter;
+import javax.ws.rs.ext.Providers;
+import javax.ws.rs.ext.ReaderInterceptor;
+import javax.ws.rs.ext.ReaderInterceptorContext;
+import javax.ws.rs.ext.WriterInterceptor;
+import javax.ws.rs.ext.WriterInterceptorContext;
 import javax.xml.namespace.QName;
 
 import org.apache.cxf.common.i18n.BundleUtils;
@@ -168,7 +169,7 @@ public final class JAXRSUtils {
     private static final String HTTP_CHARSET_PARAM = "charset";
     private static final Annotation[] EMPTY_ANNOTATIONS = new Annotation[0];
     private static final Set<Class<?>> STREAMING_OUT_TYPES = new HashSet<>(
-        Arrays.asList(InputStream.class, Reader.class, StreamingOutput.class));
+        Arrays.asList(InputStream.class, Reader.class, StreamingOutput.class, DataSource.class));
 
     private JAXRSUtils() {
     }

[tomee-jakarta] 01/03: TOMEE-3164 jaxrs.jaxrs21.ee.priority paramConverterPriorityTest

Posted by db...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

dblevins pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/tomee-jakarta.git

commit 7d50e1dc650abc2dc0fbc66fda193a6dcfa68afe
Author: David Blevins <da...@gmail.com>
AuthorDate: Fri Apr 30 01:46:28 2021 -0700

    TOMEE-3164 jaxrs.jaxrs21.ee.priority paramConverterPriorityTest
---
 .../apache/cxf/jaxrs/provider/ProviderFactory.java | 86 ++++++++++++++++++----
 1 file changed, 72 insertions(+), 14 deletions(-)

diff --git a/transform/src/patch/java/org/apache/cxf/jaxrs/provider/ProviderFactory.java b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/ProviderFactory.java
index 43f36ec..65c417c 100644
--- a/transform/src/patch/java/org/apache/cxf/jaxrs/provider/ProviderFactory.java
+++ b/transform/src/patch/java/org/apache/cxf/jaxrs/provider/ProviderFactory.java
@@ -39,19 +39,20 @@ import java.util.Set;
 import java.util.TreeMap;
 import java.util.logging.Logger;
 
-import jakarta.ws.rs.Produces;
-import jakarta.ws.rs.core.Application;
-import jakarta.ws.rs.core.Configuration;
-import jakarta.ws.rs.core.MediaType;
-import jakarta.ws.rs.core.MultivaluedMap;
-import jakarta.ws.rs.ext.ContextResolver;
-import jakarta.ws.rs.ext.ExceptionMapper;
-import jakarta.ws.rs.ext.MessageBodyReader;
-import jakarta.ws.rs.ext.MessageBodyWriter;
-import jakarta.ws.rs.ext.ParamConverter;
-import jakarta.ws.rs.ext.ParamConverterProvider;
-import jakarta.ws.rs.ext.ReaderInterceptor;
-import jakarta.ws.rs.ext.WriterInterceptor;
+import javax.annotation.Priority;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.Configuration;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.ext.ContextResolver;
+import javax.ws.rs.ext.ExceptionMapper;
+import javax.ws.rs.ext.MessageBodyReader;
+import javax.ws.rs.ext.MessageBodyWriter;
+import javax.ws.rs.ext.ParamConverter;
+import javax.ws.rs.ext.ParamConverterProvider;
+import javax.ws.rs.ext.ReaderInterceptor;
+import javax.ws.rs.ext.WriterInterceptor;
 
 import org.apache.cxf.Bus;
 import org.apache.cxf.common.classloader.ClassLoaderUtils;
@@ -77,6 +78,8 @@ import org.apache.cxf.jaxrs.utils.ResourceUtils;
 import org.apache.cxf.message.Message;
 import org.apache.cxf.message.MessageUtils;
 
+import static javax.ws.rs.Priorities.USER;
+
 public abstract class ProviderFactory {
     public static final String DEFAULT_FILTER_NAME_BINDING = "org.apache.cxf.filter.binding";
     public static final String PROVIDER_SELECTION_PROPERTY_CHANGED = "provider.selection.property.changed";
@@ -662,6 +665,7 @@ public abstract class ProviderFactory {
         sortReaders();
         sortWriters();
         sortContextResolvers();
+        sortParamConverters();
 
         mapInterceptorFilters(readerInterceptors, readInts, ReaderInterceptor.class, true);
         mapInterceptorFilters(writerInterceptors, writeInts, WriterInterceptor.class, true);
@@ -783,7 +787,9 @@ public abstract class ProviderFactory {
         contextResolvers.sort(new ContextResolverComparator());
     }
 
-
+    private void sortParamConverters() {
+        paramConverters.sort(new ParamConverterComparator());
+    }
 
 
 
@@ -1517,4 +1523,56 @@ public abstract class ProviderFactory {
         writerInterceptors = sortedWriterInterceptors;
     }
 
+    protected static class ParamConverterComparator implements Comparator<ProviderInfo<ParamConverterProvider>> {
+
+        @Override
+        public int compare(final ProviderInfo<ParamConverterProvider> a,
+                           final ProviderInfo<ParamConverterProvider> b) {
+
+            /*
+             * Primary sort.  Also takes care of sorting custom
+             * converters from system converters due to priority
+             * defaults
+             */
+            int result = sortByPriority(a, b);
+
+            /*
+             * Secondary sort as this list *will* change order
+             * once in a while between jvm restarts, which can
+             * have frustrating consequences for users who are
+             * expecting no change in behavior as they aren't
+             * changing their code.
+             */
+            if (result == 0) {
+                result = sortByClassName(a, b);
+            }
+
+            return result;
+        }
+
+        public int sortByPriority(final ProviderInfo<ParamConverterProvider> a,
+                           final ProviderInfo<ParamConverterProvider> b) {
+            final int aPriority = getPriority(a);
+            final int bPriority = getPriority(b);
+
+            // Sort ascending as the priority with the lowest number wins
+            return Integer.compare(aPriority, bPriority);
+        }
+
+        public int sortByClassName(final ProviderInfo<ParamConverterProvider> a,
+                           final ProviderInfo<ParamConverterProvider> b) {
+
+            // Sort ascending as the priority with the lowest number wins
+            return a.getProvider().getClass().getName().compareTo(b.getProvider().getClass().getName());
+        }
+
+        private int getPriority(final ProviderInfo<ParamConverterProvider> providerInfo) {
+            final Priority priority = providerInfo.getProvider().getClass().getAnnotation(Priority.class);
+            if (priority!=null) {
+                return priority.value();
+            }
+            return providerInfo.isCustom() ? USER : USER + 1000;
+        }
+    }
+
 }

[tomee-jakarta] 03/03: Merge branch 'master' of github.com:apache/tomee-jakarta

Posted by db...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

dblevins pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/tomee-jakarta.git

commit 6a96152dbdc194fcc81016279133cf854e751735
Merge: 33415ca e5db5c0
Author: David Blevins <da...@gmail.com>
AuthorDate: Fri Apr 30 01:59:55 2021 -0700

    Merge branch 'master' of github.com:apache/tomee-jakarta

 tomee/apache-tomee/pom.xml | 2 ++
 1 file changed, 2 insertions(+)