Return-Path: X-Original-To: apmail-cxf-commits-archive@www.apache.org Delivered-To: apmail-cxf-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 0BDF3FE11 for ; Tue, 2 Apr 2013 05:02:15 +0000 (UTC) Received: (qmail 10568 invoked by uid 500); 2 Apr 2013 05:02:14 -0000 Delivered-To: apmail-cxf-commits-archive@cxf.apache.org Received: (qmail 10477 invoked by uid 500); 2 Apr 2013 05:02:12 -0000 Mailing-List: contact commits-help@cxf.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@cxf.apache.org Delivered-To: mailing list commits@cxf.apache.org Received: (qmail 10448 invoked by uid 99); 2 Apr 2013 05:02:11 -0000 Received: from athena.apache.org (HELO athena.apache.org) (140.211.11.136) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 02 Apr 2013 05:02:11 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=5.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 02 Apr 2013 05:02:10 +0000 Received: from eris.apache.org (localhost [127.0.0.1]) by eris.apache.org (Postfix) with ESMTP id F30B023888CD; Tue, 2 Apr 2013 05:01:49 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1463382 - in /cxf/trunk: api/src/main/java/org/apache/cxf/annotations/ api/src/main/java/org/apache/cxf/feature/ api/src/main/java/org/apache/cxf/interceptor/ rt/core/src/main/java/org/apache/cxf/service/factory/ Date: Tue, 02 Apr 2013 05:01:49 -0000 To: commits@cxf.apache.org From: ffang@apache.org X-Mailer: svnmailer-1.0.8-patched Message-Id: <20130402050149.F30B023888CD@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Author: ffang Date: Tue Apr 2 05:01:49 2013 New Revision: 1463382 URL: http://svn.apache.org/r1463382 Log: [CXF-4936]Expose FastInfoset serializer tuning properties Modified: cxf/trunk/api/src/main/java/org/apache/cxf/annotations/FastInfoset.java cxf/trunk/api/src/main/java/org/apache/cxf/feature/FastInfosetFeature.java cxf/trunk/api/src/main/java/org/apache/cxf/interceptor/FIStaxOutInterceptor.java cxf/trunk/rt/core/src/main/java/org/apache/cxf/service/factory/AnnotationsFactoryBeanListener.java Modified: cxf/trunk/api/src/main/java/org/apache/cxf/annotations/FastInfoset.java URL: http://svn.apache.org/viewvc/cxf/trunk/api/src/main/java/org/apache/cxf/annotations/FastInfoset.java?rev=1463382&r1=1463381&r2=1463382&view=diff ============================================================================== --- cxf/trunk/api/src/main/java/org/apache/cxf/annotations/FastInfoset.java (original) +++ cxf/trunk/api/src/main/java/org/apache/cxf/annotations/FastInfoset.java Tue Apr 2 05:01:49 2013 @@ -32,6 +32,51 @@ import java.lang.annotation.Target; @Retention(RetentionPolicy.RUNTIME) @Target({ ElementType.TYPE }) public @interface FastInfoset { + /** + * Set to true in order for FastInfoset to be always used without negotiation + */ boolean force() default false; + + /** + * Sets the property attributeValueMapMemoryLimit on FastInfoset StAX Serializers. The property + * controls attribute value map size and can be used to control the memory and (indirectly) CPU footprint of + * processing. + */ + int serializerAttributeValueMapMemoryLimit() default -1; + + /** + * Sets the property minAttributeValueSize on FastInfoset StAX Serializers. The property controls the + * minimum size of attribute values to be indexed. + */ + int serializerMinAttributeValueSize() default -1; + + /** + * Sets the property maxAttributeValueSize on FastInfoset StAX Serializers. The property controls the + * maximum size of attribute values to be indexed. Tests have shown that setting this property to lower + * values reduces CPU burden of processing, at the expense of larger sizes of resultant encoded Fast Infoset data. + */ + int serializerMaxAttributeValueSize() default -1; + + /** + * Sets the property characterContentChunkMapMemoryLimit on FastInfoset StAX Serializers. The property + * controls character content chunk map size and can be used to control the memory and (indirectly) CPU footprint of + * processing. + */ + int serializerCharacterContentChunkMapMemoryLimit() default -1; + + /** + * Sets the property minCharacterContentChunkSize on FastInfoset StAX Serializers. The property + * controls the minimum size of character content chunks to be indexed. + */ + int serializerMinCharacterContentChunkSize() default -1; + + /** + * Sets the property maxCharacterContentChunkSize on FastInfoset StAX Serializers. The property + * controls the maximum size of character content chunks to be indexed. Tests have shown that setting this + * property to lower values reduces CPU burden of processing, at the expense of larger sizes of resultant encoded + * Fast Infoset data. + */ + int serializerMaxCharacterContentChunkSize() default -1; + } Modified: cxf/trunk/api/src/main/java/org/apache/cxf/feature/FastInfosetFeature.java URL: http://svn.apache.org/viewvc/cxf/trunk/api/src/main/java/org/apache/cxf/feature/FastInfosetFeature.java?rev=1463382&r1=1463381&r2=1463382&view=diff ============================================================================== --- cxf/trunk/api/src/main/java/org/apache/cxf/feature/FastInfosetFeature.java (original) +++ cxf/trunk/api/src/main/java/org/apache/cxf/feature/FastInfosetFeature.java Tue Apr 2 05:01:49 2013 @@ -38,9 +38,15 @@ import org.apache.cxf.interceptor.Interc */ @NoJSR250Annotations public class FastInfosetFeature extends AbstractFeature { - + boolean force; - + private Integer serializerAttributeValueMapMemoryLimit; + private Integer serializerMinAttributeValueSize; + private Integer serializerMaxAttributeValueSize; + private Integer serializerCharacterContentChunkMapMemoryLimit; + private Integer serializerMinCharacterContentChunkSize; + private Integer serializerMaxCharacterContentChunkSize; + public FastInfosetFeature() { // } @@ -50,7 +56,29 @@ public class FastInfosetFeature extends protected void initializeProvider(InterceptorProvider provider, Bus bus) { FIStaxInInterceptor in = new FIStaxInInterceptor(); + FIStaxOutInterceptor out = new FIStaxOutInterceptor(force); + if (serializerAttributeValueMapMemoryLimit != null && serializerAttributeValueMapMemoryLimit.intValue() > 0) { + out.setSerializerAttributeValueMapMemoryLimit(serializerAttributeValueMapMemoryLimit.intValue()); + } + if (serializerMinAttributeValueSize != null && serializerMinAttributeValueSize.intValue() > 0) { + out.setSerializerMinAttributeValueSize(serializerMinAttributeValueSize.intValue()); + } + if (serializerMaxAttributeValueSize != null && serializerMaxAttributeValueSize.intValue() > 0) { + out.setSerializerMaxAttributeValueSize(serializerMaxAttributeValueSize.intValue()); + } + if (serializerCharacterContentChunkMapMemoryLimit != null + && serializerCharacterContentChunkMapMemoryLimit.intValue() > 0) { + out.setSerializerCharacterContentChunkMapMemoryLimit( + serializerCharacterContentChunkMapMemoryLimit.intValue()); + } + if (serializerMinCharacterContentChunkSize != null && serializerMinCharacterContentChunkSize.intValue() > 0) { + out.setSerializerMinCharacterContentChunkSize(serializerMinCharacterContentChunkSize.intValue()); + } + if (serializerMaxCharacterContentChunkSize != null && serializerMaxCharacterContentChunkSize.intValue() > 0) { + out.setSerializerMaxCharacterContentChunkSize(serializerMaxCharacterContentChunkSize.intValue()); + } + provider.getInInterceptors().add(in); provider.getInFaultInterceptors().add(in); provider.getOutInterceptors().add(out); Modified: cxf/trunk/api/src/main/java/org/apache/cxf/interceptor/FIStaxOutInterceptor.java URL: http://svn.apache.org/viewvc/cxf/trunk/api/src/main/java/org/apache/cxf/interceptor/FIStaxOutInterceptor.java?rev=1463382&r1=1463381&r2=1463382&view=diff ============================================================================== --- cxf/trunk/api/src/main/java/org/apache/cxf/interceptor/FIStaxOutInterceptor.java (original) +++ cxf/trunk/api/src/main/java/org/apache/cxf/interceptor/FIStaxOutInterceptor.java Tue Apr 2 05:01:49 2013 @@ -24,12 +24,15 @@ import java.io.OutputStream; import java.util.ArrayList; import java.util.List; import java.util.Map; +import java.util.logging.Level; +import java.util.logging.Logger; import javax.xml.stream.XMLStreamException; import javax.xml.stream.XMLStreamWriter; import com.sun.xml.fastinfoset.stax.StAXDocumentSerializer; +import org.apache.cxf.common.logging.LogUtils; import org.apache.cxf.helpers.CastUtils; import org.apache.cxf.message.Message; import org.apache.cxf.message.MessageUtils; @@ -42,11 +45,19 @@ import org.apache.cxf.phase.Phase; */ public class FIStaxOutInterceptor extends AbstractPhaseInterceptor { public static final String FI_ENABLED = "org.apache.cxf.fastinfoset.enabled"; + + private static final Logger LOG = LogUtils.getL7dLogger(FIStaxOutInterceptor.class); private static final String OUTPUT_STREAM_HOLDER = FIStaxOutInterceptor.class.getName() + ".outputstream"; private static final StaxOutEndingInterceptor ENDING = new StaxOutEndingInterceptor(OUTPUT_STREAM_HOLDER); boolean force; - + private Integer serializerAttributeValueMapMemoryLimit; + private Integer serializerMinAttributeValueSize; + private Integer serializerMaxAttributeValueSize; + private Integer serializerCharacterContentChunkMapMemoryLimit; + private Integer serializerMinCharacterContentChunkSize; + private Integer serializerMaxCharacterContentChunkSize; + public FIStaxOutInterceptor() { super(Phase.PRE_STREAM); addAfter(AttachmentOutInterceptor.class.getName()); @@ -138,8 +149,140 @@ public class FIStaxOutInterceptor extend } return serializer; */ - return new StAXDocumentSerializer(out); + final StAXDocumentSerializer stAXDocumentSerializer = new StAXDocumentSerializer(out); + if (serializerAttributeValueMapMemoryLimit != null && serializerAttributeValueMapMemoryLimit.intValue() > 0) { + stAXDocumentSerializer.setAttributeValueMapMemoryLimit(serializerAttributeValueMapMemoryLimit.intValue()); + } + if (serializerMinAttributeValueSize != null && serializerMinAttributeValueSize.intValue() > 0) { + stAXDocumentSerializer.setMinAttributeValueSize(serializerMinAttributeValueSize.intValue()); + } + if (serializerMaxAttributeValueSize != null && serializerMaxAttributeValueSize.intValue() > 0) { + stAXDocumentSerializer.setMaxAttributeValueSize(serializerMaxAttributeValueSize.intValue()); + } + if (serializerCharacterContentChunkMapMemoryLimit != null + && serializerCharacterContentChunkMapMemoryLimit.intValue() > 0) { + stAXDocumentSerializer + .setCharacterContentChunkMapMemoryLimit(serializerCharacterContentChunkMapMemoryLimit.intValue()); + } + if (serializerMinCharacterContentChunkSize != null && serializerMinCharacterContentChunkSize.intValue() > 0) { + stAXDocumentSerializer.setMinCharacterContentChunkSize(serializerMinCharacterContentChunkSize.intValue()); + } + if (serializerMaxCharacterContentChunkSize != null && serializerMaxCharacterContentChunkSize.intValue() > 0) { + stAXDocumentSerializer.setMaxCharacterContentChunkSize(serializerMaxCharacterContentChunkSize.intValue()); + } + return stAXDocumentSerializer; + } + + public Integer getSerializerMinAttributeValueSize() { + return serializerMinAttributeValueSize; + } + + /** + * Sets the property minAttributeValueSize on FastInfoset StAX Serializers created and used + * by this interceptor. The property controls the minimum size of attribute values to be indexed. + * + * @param serializerMinAttributeValueSize + * The minimum size for attribute values to be indexed, + * measured as a number of characters. The default is typically 0. + */ + public void setSerializerMinAttributeValueSize(Integer serializerMinAttributeValueSize) { + logSetter("serializerMinAttributeValueSize", serializerMinAttributeValueSize); + this.serializerMinAttributeValueSize = serializerMinAttributeValueSize; + } + + public Integer getSerializerMaxAttributeValueSize() { + return serializerMaxAttributeValueSize; + } + + /** + * Sets the property maxAttributeValueSize on FastInfoset StAX Serializers created and used + * by this interceptor. The property controls the maximum size of attribute values to be indexed. + * Tests have shown that setting this property to lower values reduces CPU burden of processing, at the expense + * of larger sizes of resultant encoded Fast Infoset data. + * + * @param serializerMaxAttributeValueSize + * The maximum size for attribute values to be indexed, + * measured as a number of characters. The default is typically 32. + */ + public void setSerializerMaxAttributeValueSize(Integer serializerMaxAttributeValueSize) { + logSetter("serializerMaxAttributeValueSize", serializerMaxAttributeValueSize); + this.serializerMaxAttributeValueSize = serializerMaxAttributeValueSize; } - + public Integer getSerializerCharacterContentChunkMapMemoryLimit() { + return serializerCharacterContentChunkMapMemoryLimit; + } + + /** + * Sets the property characterContentChunkMapMemoryLimit on FastInfoset StAX Serializers created and + * used by this interceptor. The property controls character content chunk map size and can be used to control the + * memory and (indirectly) CPU footprint of processing. + * + * @param serializerCharacterContentChunkMapMemoryLimit + * The value for the limit, measured as a number of Unicode characters. + */ + public void setSerializerCharacterContentChunkMapMemoryLimit( + Integer serializerCharacterContentChunkMapMemoryLimit) { + logSetter("serializerCharacterContentChunkMapMemoryLimit", serializerCharacterContentChunkMapMemoryLimit); + this.serializerCharacterContentChunkMapMemoryLimit = serializerCharacterContentChunkMapMemoryLimit; + } + + public Integer getSerializerMinCharacterContentChunkSize() { + return serializerMinCharacterContentChunkSize; + } + + /** + * Sets the property minCharacterContentChunkSize on FastInfoset StAX Serializers created and used + * by this interceptor. The property controls the minimum size of character content chunks to be indexed. + * + * @param serializerMinCharacterContentChunkSize + * The minimum size for character content chunks to be indexed, + * measured as a number of characters. The default is typically 0. + */ + public void setSerializerMinCharacterContentChunkSize(Integer serializerMinCharacterContentChunkSize) { + logSetter("serializerMinCharacterContentChunkSize", serializerMinCharacterContentChunkSize); + this.serializerMinCharacterContentChunkSize = serializerMinCharacterContentChunkSize; + } + + public Integer getSerializerMaxCharacterContentChunkSize() { + return serializerMaxCharacterContentChunkSize; + } + + /** + * Sets the property maxCharacterContentChunkSize on FastInfoset StAX Serializers created and used + * by this interceptor. The property controls the maximum size of character content chunks to be indexed. + * Tests have shown that setting this property to lower values reduces CPU burden of processing, at the expense + * of larger sizes of resultant encoded Fast Infoset data. + * + * @param serializerMaxCharacterContentChunkSize + * The maximum size for character content chunks to be indexed, + * measured as a number of characters. The default is typically 32. + */ + public void setSerializerMaxCharacterContentChunkSize(Integer serializerMaxCharacterContentChunkSize) { + logSetter("serializerMaxCharacterContentChunkSize", serializerMaxCharacterContentChunkSize); + this.serializerMaxCharacterContentChunkSize = serializerMaxCharacterContentChunkSize; + } + + public Integer getSerializerAttributeValueMapMemoryLimit() { + return serializerAttributeValueMapMemoryLimit; + } + + /** + * Sets the property attributeValueMapMemoryLimit on FastInfoset StAX Serializers created and used + * by this interceptor. The property controls attribute value map size and can be used to control + * the memory and (indirectly) CPU footprint of processing. + * + * @param serializerAttributeValueMapMemoryLimit + * The value for the limit, measured as a number of Unicode characters. + */ + public void setSerializerAttributeValueMapMemoryLimit(Integer serializerAttributeValueMapMemoryLimit) { + logSetter("serializerAttributeValueMapMemoryLimit", serializerAttributeValueMapMemoryLimit); + this.serializerAttributeValueMapMemoryLimit = serializerAttributeValueMapMemoryLimit; + } + + private void logSetter(String propertyName, Object propertyValue) { + if (LOG.isLoggable(Level.CONFIG)) { + LOG.config("Setting " + propertyName + " to " + propertyValue); + } + } } Modified: cxf/trunk/rt/core/src/main/java/org/apache/cxf/service/factory/AnnotationsFactoryBeanListener.java URL: http://svn.apache.org/viewvc/cxf/trunk/rt/core/src/main/java/org/apache/cxf/service/factory/AnnotationsFactoryBeanListener.java?rev=1463382&r1=1463381&r2=1463382&view=diff ============================================================================== --- cxf/trunk/rt/core/src/main/java/org/apache/cxf/service/factory/AnnotationsFactoryBeanListener.java (original) +++ cxf/trunk/rt/core/src/main/java/org/apache/cxf/service/factory/AnnotationsFactoryBeanListener.java Tue Apr 2 05:01:49 2013 @@ -281,7 +281,16 @@ public class AnnotationsFactoryBeanListe private void addFastInfosetSupport(InterceptorProvider provider, FastInfoset annotation) { if (annotation != null) { FIStaxInInterceptor in = new FIStaxInInterceptor(); + FIStaxOutInterceptor out = new FIStaxOutInterceptor(annotation.force()); + out.setSerializerAttributeValueMapMemoryLimit(annotation.serializerAttributeValueMapMemoryLimit()); + out.setSerializerMinAttributeValueSize(annotation.serializerMinAttributeValueSize()); + out.setSerializerMaxAttributeValueSize(annotation.serializerMaxAttributeValueSize()); + out.setSerializerCharacterContentChunkMapMemoryLimit( + annotation.serializerCharacterContentChunkMapMemoryLimit()); + out.setSerializerMinCharacterContentChunkSize(annotation.serializerMinCharacterContentChunkSize()); + out.setSerializerMaxCharacterContentChunkSize(annotation.serializerMaxCharacterContentChunkSize()); + provider.getInInterceptors().add(in); provider.getInFaultInterceptors().add(in); provider.getOutInterceptors().add(out);