You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-commits@axis.apache.org by ba...@apache.org on 2011/02/09 18:13:37 UTC
svn commit: r1068985 - in /axis/axis2/java/core/trunk/modules:
jaxws/test/org/apache/axis2/jaxws/client/
jaxws/test/org/apache/axis2/jaxws/client/dispatch/
metadata/src/org/apache/axis2/jaxws/description/builder/
metadata/src/org/apache/axis2/jaxws/des...
Author: barrettj
Date: Wed Feb 9 17:13:37 2011
New Revision: 1068985
URL: http://svn.apache.org/viewvc?rev=1068985&view=rev
Log:
AXIS2-4952
Scope dynamic ports to the instance of the service that did the addPort(...). Add TDD Unit test and flag to revert to previous behavior of sharing dynamic ports across services.
Modified:
axis/axis2/java/core/trunk/modules/jaxws/test/org/apache/axis2/jaxws/client/ReleaseServiceTests.java
axis/axis2/java/core/trunk/modules/jaxws/test/org/apache/axis2/jaxws/client/dispatch/DynamicPortCachingTests.java
axis/axis2/java/core/trunk/modules/metadata/src/org/apache/axis2/jaxws/description/builder/MDQConstants.java
axis/axis2/java/core/trunk/modules/metadata/src/org/apache/axis2/jaxws/description/impl/ServiceDescriptionImpl.java
Modified: axis/axis2/java/core/trunk/modules/jaxws/test/org/apache/axis2/jaxws/client/ReleaseServiceTests.java
URL: http://svn.apache.org/viewvc/axis/axis2/java/core/trunk/modules/jaxws/test/org/apache/axis2/jaxws/client/ReleaseServiceTests.java?rev=1068985&r1=1068984&r2=1068985&view=diff
==============================================================================
--- axis/axis2/java/core/trunk/modules/jaxws/test/org/apache/axis2/jaxws/client/ReleaseServiceTests.java (original)
+++ axis/axis2/java/core/trunk/modules/jaxws/test/org/apache/axis2/jaxws/client/ReleaseServiceTests.java Wed Feb 9 17:13:37 2011
@@ -118,16 +118,27 @@ public class ReleaseServiceTests extends
* before the next one is created. This should release the resources for that service. The
* number of services and ports created is large enough to cause an OOM if the release isn't
* being done correctly.
+ *
+ * IMPORTANT NOTE! Due to a change where dynamic ports are not shared across services,
+ * it *may* be that too many ports are being added, which could result in an OOM before
+ * they can be released. The OOM does not necessarily indicate that the services are
+ * not being released; it may indicate that the given number of dynamic ports, now not
+ * shared across services, is too large. Even though the dynamic ports are being relased
+ * the memory is not freed up for re-use until garbage collection is run.
+ *
+ * NOTE: This test is disabled because forcing garbage collection is an inexact science
+ * at best. You can only ask the JVM to consider doing GC, and that behaves differently
+ * on different JVMS. So, there's no reliable way to make sure this test runs on various
+ * JVMs. So, it is disabled.
*/
- public void testMultipleServiceMultiplePortReleaseLoop() {
+ public void _DISABLED_testMultipleServiceMultiplePortReleaseLoop() {
// Create a bunch of different services, make sure the service desc finalizer is called
try {
ClientMetadataTest.installCachingFactory();
-
for (int i = 0; i < 1000; i++) {
QName svcQN = new QName(namespaceURI, svcLocalPart + "_" + i);
Service svc1 = Service.create(svcQN);
- for (int j = 0; j < 200; j++) {
+ for (int j = 0; j < 100; j++) {
QName portQN = new QName(namespaceURI, dynamicPort1 + "_svc_" + i + "_port_" + j);
svc1.addPort(portQN, bindingID1, epr1);
}
@@ -545,17 +556,17 @@ public class ReleaseServiceTests extends
EndpointDescription epDesc1_port1 = svcDesc1.getEndpointDescription(portQN1, sd1);
EndpointDescription epDesc2_port1 = svcDesc1.getEndpointDescription(portQN1, sd2);
- assertSame(epDesc1_port1, epDesc2_port1);
+ assertNotSame(epDesc1_port1, epDesc2_port1);
AxisService axisSvc1_port1 = epDesc1_port1.getAxisService();
AxisService axisSvc2_port1 = epDesc2_port1.getAxisService();
- assertSame(axisSvc1_port1, axisSvc2_port1);
+ assertNotSame(axisSvc1_port1, axisSvc2_port1);
EndpointDescription epDesc1_port2 = svcDesc1.getEndpointDescription(portQN2, sd1);
EndpointDescription epDesc2_port2 = svcDesc1.getEndpointDescription(portQN2, sd2);
- assertSame(epDesc1_port2, epDesc2_port2);
+ assertNotSame(epDesc1_port2, epDesc2_port2);
AxisService axisSvc1_port2 = epDesc1_port2.getAxisService();
AxisService axisSvc2_port2 = epDesc2_port2.getAxisService();
- assertSame(axisSvc1_port2, axisSvc2_port2);
+ assertNotSame(axisSvc1_port2, axisSvc2_port2);
// First close should NOT cleanup the endpoints since the other service is
// still using them.
@@ -584,9 +595,9 @@ public class ReleaseServiceTests extends
ServiceDescription svcDesc3 = sd3.getServiceDescription();
assertSame(svcDesc2_afterClose, svcDesc3);
EndpointDescription epDesc3_port1 = svcDesc3.getEndpointDescription(portQN1, sd3);
- assertSame(epDesc3_port1, epDesc2_port1_afterClose);
+ assertNotSame(epDesc3_port1, epDesc2_port1_afterClose);
EndpointDescription epDesc3_port2 = svcDesc3.getEndpointDescription(portQN2, sd3);
- assertSame(epDesc3_port2, epDesc2_port2_afterClose);
+ assertNotSame(epDesc3_port2, epDesc2_port2_afterClose);
// Close the 2nd delegate and make sure cahced objects are still there
// since there's a 3rd delegate now
@@ -824,7 +835,7 @@ public class ReleaseServiceTests extends
QName portQN2 = new QName(namespaceURI, dynamicPort1 + "_2");
QName portQN3 = new QName(namespaceURI, dynamicPort1 + "_3");
QName portQN4 = new QName(namespaceURI, dynamicPort1 + "_4");
- QName portQN5 = new QName(namespaceURI, dynamicPort1 + "_4");
+ QName portQN5 = new QName(namespaceURI, dynamicPort1 + "_5");
svc1.addPort(portQN1,bindingID1, epr1);
svc1.addPort(portQN2,bindingID1, epr1);
@@ -858,25 +869,25 @@ public class ReleaseServiceTests extends
// Since the services descriptions are shared, use this in the rest of the test for clarity
ServiceDescription svcDesc = svcDesc1;
- // Make sure the endpoint descriptions for the same ports are shared across the
+ // Make sure the endpoint descriptions for the same ports are not shared across the
// delegate instances
EndpointDescription epDesc1_port1 = svcDesc.getEndpointDescription(portQN1, sd1);
EndpointDescription epDesc2_port1 = svcDesc.getEndpointDescription(portQN1, sd2);
- assertSame(epDesc1_port1, epDesc2_port1);
+ assertNotSame(epDesc1_port1, epDesc2_port1);
AxisService axisSvc1_port1 = epDesc1_port1.getAxisService();
AxisService axisSvc2_port1 = epDesc2_port1.getAxisService();
- assertSame(axisSvc1_port1, axisSvc2_port1);
+ assertNotSame(axisSvc1_port1, axisSvc2_port1);
AxisService portQN1_AxisService = axisSvc1_port1;
AxisService portQN3_AxisService = svcDesc.getEndpointDescription(portQN3, sd1).getAxisService();
assertNull(svcDesc.getEndpointDescription(portQN1, sd3));
EndpointDescription epDesc1_port2 = svcDesc.getEndpointDescription(portQN2, sd1);
EndpointDescription epDesc2_port2 = svcDesc.getEndpointDescription(portQN2, sd2);
- assertSame(epDesc1_port2, epDesc2_port2);
+ assertNotSame(epDesc1_port2, epDesc2_port2);
AxisService axisSvc1_port2 = epDesc1_port2.getAxisService();
AxisService axisSvc2_port2 = epDesc2_port2.getAxisService();
- assertSame(axisSvc1_port2, axisSvc2_port2);
+ assertNotSame(axisSvc1_port2, axisSvc2_port2);
AxisService portQN2_AxisService = axisSvc1_port2;
EndpointDescription epDesc3_port4 = svcDesc.getEndpointDescription(portQN4, sd3);
@@ -895,9 +906,9 @@ public class ReleaseServiceTests extends
// Should remove the entries for this delegate
assertNull(svcDesc.getEndpointDescription(portQN1, sd1));
assertNull(svcDesc.getEndpointDescription(portQN2, sd1));
- // Should only release port 3 since 1 and 2 are shared and 4 wasn't added to this delegate
- assertTrue(axisConfig.getServiceGroup(portQN1_AxisService.getAxisServiceGroup().getServiceGroupName()) != null);
- assertTrue(axisConfig.getServiceGroup(portQN2_AxisService.getAxisServiceGroup().getServiceGroupName()) != null);
+ // Should only release all ports added to this service; 4 wasn't added to this delegate
+ assertTrue(axisConfig.getServiceGroup(portQN1_AxisService.getAxisServiceGroup().getServiceGroupName()) == null);
+ assertTrue(axisConfig.getServiceGroup(portQN2_AxisService.getAxisServiceGroup().getServiceGroupName()) == null);
assertTrue(axisConfig.getServiceGroup(portQN3_AxisService.getAxisServiceGroup().getServiceGroupName()) == null);
assertTrue(axisConfig.getServiceGroup(portQN4_AxisService.getAxisServiceGroup().getServiceGroupName()) != null);
Modified: axis/axis2/java/core/trunk/modules/jaxws/test/org/apache/axis2/jaxws/client/dispatch/DynamicPortCachingTests.java
URL: http://svn.apache.org/viewvc/axis/axis2/java/core/trunk/modules/jaxws/test/org/apache/axis2/jaxws/client/dispatch/DynamicPortCachingTests.java?rev=1068985&r1=1068984&r2=1068985&view=diff
==============================================================================
--- axis/axis2/java/core/trunk/modules/jaxws/test/org/apache/axis2/jaxws/client/dispatch/DynamicPortCachingTests.java (original)
+++ axis/axis2/java/core/trunk/modules/jaxws/test/org/apache/axis2/jaxws/client/dispatch/DynamicPortCachingTests.java Wed Feb 9 17:13:37 2011
@@ -19,26 +19,41 @@
package org.apache.axis2.jaxws.client.dispatch;
import junit.framework.TestCase;
+
+import org.apache.axis2.AxisFault;
+import org.apache.axis2.description.Parameter;
+import org.apache.axis2.engine.AxisConfiguration;
+import org.apache.axis2.jaxws.Constants;
import org.apache.axis2.jaxws.description.DescriptionTestUtils2;
+import org.apache.axis2.jaxws.description.EndpointDescription;
import org.apache.axis2.jaxws.description.ServiceDescription;
+import org.apache.axis2.jaxws.description.builder.MDQConstants;
+import org.apache.axis2.jaxws.description.impl.ServiceDescriptionImpl;
import org.apache.axis2.jaxws.spi.ClientMetadataTest;
import org.apache.axis2.jaxws.spi.ServiceDelegate;
import javax.xml.namespace.QName;
import javax.xml.ws.Service;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.Iterator;
import java.util.List;
/**
* Tests the caching and isolation of dynamic ports,i.e. those created with
* Service.addPort(...). Dynamic ports should
- * 1) Only be visible to services on which an addPort was done
+ * 1) Only be visible to the service instances on which an addPort was done
* 2) Share instances of the description objects (e.g. AxisService) for ports
- * added to different instances of the same service that use the same client
- * configuration
- * 3) Identical ports on services using different client configuration should
- * not be shared
+ * added to the same instance of a service
+ * 3) Different service instances of the same-named service should not share the
+ * the list of added dynamic ports. Even if the same named port is added to each
+ * service, they should not share metadata objects (e.g. EndpointDescription, AxisService)
+ *
+ * Also validate the property that enables the previous behavior that allowed
+ * sharing of dyamic ports across services on the same AxisConfiguration. With
+ * that property enabled, Dynamic ports should
+ * 1) Be shared across all services on the AxisConfiguration based on the key
+ * (PortQName, BindingId, EndpointAddress).
*/
public class DynamicPortCachingTests extends TestCase {
static final String namespaceURI = "http://dispatch.client.jaxws.axis2.apache.org";
@@ -49,11 +64,149 @@ public class DynamicPortCachingTests ext
static final String epr1 = null;
/**
- * Two different instances of the same service should share the same
- * description information (e.g. AxisService) if the same port is added
- * to both
+ * Validate setting the property enables the old behavior, which is that dynamic ports are
+ * shared across all services on an AxisConfiguration based on the key
+ * (PortQName, BindingId, EndpointAddress). This test validates that two ports that share the
+ * same Service QName will be share the same dynamic port objects.
+ *
+ * NOTE!!! This test exists for validating backwards compatability. This behavior was NOT
+ * intended in the runtime, but since it existed that way, customers could be depending on it.
+ */
+ public void testSamePortsSameServiceName_AxisConfig_PropertyTrue() {
+ try {
+ ClientMetadataTest.installCachingFactory();
+ QName svcQN = new QName(namespaceURI, svcLocalPart);
+
+ Service svc1 = Service.create(svcQN);
+ assertNotNull(svc1);
+ ServiceDelegate svcDlg1 = DescriptionTestUtils2.getServiceDelegate(svc1);
+ assertNotNull(svcDlg1);
+ ServiceDescription svcDesc1 = svcDlg1.getServiceDescription();
+ assertNotNull(svcDesc1);
+
+ // Set the property to revert the behavior. Note that although we are passing ni
+ // a particular service, the property is set on the AxisConfig shared by all
+ // services.
+ setAxisConfigParameter(svc1, MDQConstants.SHARE_DYNAMIC_PORTS_ACROSS_SERVICES, "true");
+
+ Service svc2 = Service.create(svcQN);
+ assertNotNull(svc2);
+ ServiceDelegate svcDlg2 = DescriptionTestUtils2.getServiceDelegate(svc2);
+ assertNotNull(svcDlg2);
+ ServiceDescription svcDesc2 = svcDlg2.getServiceDescription();
+ assertNotNull(svcDesc2);
+
+ assertNotSame("Service instances should not be the same", svc1, svc2);
+ assertNotSame("Service delegates should not be the same", svcDlg1, svcDlg2);
+ assertSame("Instance of ServiceDescription should be the same", svcDesc1, svcDesc2);
+
+ // Add a port to 1st service, should not be visible under the 2nd service
+ svc1.addPort(new QName(namespaceURI, dynamicPort1),
+ bindingID1,
+ epr1);
+ assertEquals(1, getList(svc1.getPorts()).size());
+ assertEquals(0, getList(svc2.getPorts()).size());
+
+ // Add the same port to 2nd service, should now have same ports and description
+ // objects
+ svc2.addPort(new QName(namespaceURI, dynamicPort1),
+ bindingID1,
+ epr1);
+ assertEquals(1, getList(svc1.getPorts()).size());
+ assertEquals(1, getList(svc2.getPorts()).size());
+
+ // Make sure the EndpointDescription objects are shared.
+ Collection<?> epDesc1Collection =
+ ((ServiceDescriptionImpl) svcDesc1).getDynamicEndpointDescriptions_AsCollection(svcDlg1);
+ Collection<?> epDesc2Collection =
+ ((ServiceDescriptionImpl) svcDesc2).getDynamicEndpointDescriptions_AsCollection(svcDlg2);
+ assertEquals("Wrong number of dynamic endpoints", 1, epDesc1Collection.size());
+ assertEquals("Wrong number of dynamic endpoints", 1, epDesc2Collection.size());
+
+ EndpointDescription epDesc1 = (EndpointDescription) epDesc1Collection.toArray()[0];
+ EndpointDescription epDesc2 = (EndpointDescription) epDesc2Collection.toArray()[0];
+ assertSame("EndpointDescriptions not shared", epDesc1, epDesc2);
+
+ } finally {
+ ClientMetadataTest.restoreOriginalFactory();
+ }
+
+ }
+ /**
+ * Validate setting the property enables the old behavior, which is that dynamic ports are
+ * shared across all services on an AxisConfiguration based on the key
+ * (PortQName, BindingId, EndpointAddress). This test validates that two ports that have
+ * different Service QNames will still share the same dynamic port objects.
+ *
+ * NOTE!!! This test exists for validating backwards compatability. This behavior was NOT
+ * intended in the runtime, but since it existed that way, customers could be depending on it.
+ */
+ public void testSamePortsDifferentServiceName_AxisConfig_PropertyTrue() {
+ try {
+ ClientMetadataTest.installCachingFactory();
+ QName svcQN = new QName(namespaceURI, svcLocalPart);
+
+ Service svc1 = Service.create(svcQN);
+ assertNotNull(svc1);
+ ServiceDelegate svcDlg1 = DescriptionTestUtils2.getServiceDelegate(svc1);
+ assertNotNull(svcDlg1);
+ ServiceDescription svcDesc1 = svcDlg1.getServiceDescription();
+ assertNotNull(svcDesc1);
+
+ // Set the property to revert the behavior. Note that although we are passing ni
+ // a particular service, the property is set on the AxisConfig shared by all
+ // services.
+ setAxisConfigParameter(svc1, MDQConstants.SHARE_DYNAMIC_PORTS_ACROSS_SERVICES, "true");
+
+ QName svcQN2 = new QName(namespaceURI, svcLocalPart + "2");
+ Service svc2 = Service.create(svcQN2);
+ assertNotNull(svc2);
+ ServiceDelegate svcDlg2 = DescriptionTestUtils2.getServiceDelegate(svc2);
+ assertNotNull(svcDlg2);
+ ServiceDescription svcDesc2 = svcDlg2.getServiceDescription();
+ assertNotNull(svcDesc2);
+
+ assertNotSame("Service instances should not be the same", svc1, svc2);
+ assertNotSame("Service delegates should not be the same", svcDlg1, svcDlg2);
+ assertNotSame("Instance of ServiceDescription should be the same", svcDesc1, svcDesc2);
+
+ // Add a port to 1st service, should not be visible under the 2nd service
+ svc1.addPort(new QName(namespaceURI, dynamicPort1),
+ bindingID1,
+ epr1);
+ assertEquals(1, getList(svc1.getPorts()).size());
+ assertEquals(0, getList(svc2.getPorts()).size());
+
+ // Add the same port to 2nd service, should now have same ports and description
+ // objects
+ svc2.addPort(new QName(namespaceURI, dynamicPort1),
+ bindingID1,
+ epr1);
+ assertEquals(1, getList(svc1.getPorts()).size());
+ assertEquals(1, getList(svc2.getPorts()).size());
+
+ // Make sure the EndpointDescription objects are shared.
+ Collection<?> epDesc1Collection =
+ ((ServiceDescriptionImpl) svcDesc1).getDynamicEndpointDescriptions_AsCollection(svcDlg1);
+ Collection<?> epDesc2Collection =
+ ((ServiceDescriptionImpl) svcDesc2).getDynamicEndpointDescriptions_AsCollection(svcDlg2);
+ assertEquals("Wrong number of dynamic endpoints", 1, epDesc1Collection.size());
+ assertEquals("Wrong number of dynamic endpoints", 1, epDesc2Collection.size());
+
+ EndpointDescription epDesc1 = (EndpointDescription) epDesc1Collection.toArray()[0];
+ EndpointDescription epDesc2 = (EndpointDescription) epDesc2Collection.toArray()[0];
+ assertSame("EndpointDescriptions not shared", epDesc1, epDesc2);
+
+ } finally {
+ ClientMetadataTest.restoreOriginalFactory();
+ }
+
+ }
+ /**
+ * Validate that without the property set to revert the behavior, the default is that the ports are
+ * NOT shared across different instances of services with the same name
*/
- public void _testSamePortsSameService() {
+ public void testSamePortsSameServiceNameDifferentInstances() {
try {
ClientMetadataTest.installCachingFactory();
QName svcQN = new QName(namespaceURI, svcLocalPart);
@@ -91,8 +244,122 @@ public class DynamicPortCachingTests ext
assertEquals(1, getList(svc1.getPorts()).size());
assertEquals(1, getList(svc2.getPorts()).size());
+ // Make sure the EndpointDescription objects are not shared.
+ Collection<?> epDesc1Collection =
+ ((ServiceDescriptionImpl) svcDesc1).getDynamicEndpointDescriptions_AsCollection(svcDlg1);
+ Collection<?> epDesc2Collection =
+ ((ServiceDescriptionImpl) svcDesc2).getDynamicEndpointDescriptions_AsCollection(svcDlg2);
+ assertEquals("Wrong number of dynamic endpoints", 1, epDesc1Collection.size());
+ assertEquals("Wrong number of dynamic endpoints", 1, epDesc2Collection.size());
+
+ EndpointDescription epDesc1 = (EndpointDescription) epDesc1Collection.toArray()[0];
+ EndpointDescription epDesc2 = (EndpointDescription) epDesc2Collection.toArray()[0];
+ assertNotSame("EndpointDescriptions not shared", epDesc1, epDesc2);
+ } finally {
+ ClientMetadataTest.restoreOriginalFactory();
+ }
+
+ }
+
+ /**
+ * Validate that adding the same dynamic port to the same service instance re-uses the same
+ * description objects (e.g. EndpointDescription)
+ */
+ public void testSamePortsSameServiceInstance() {
+ try {
+ ClientMetadataTest.installCachingFactory();
+ QName svcQN = new QName(namespaceURI, svcLocalPart);
+
+ Service svc1 = Service.create(svcQN);
+ assertNotNull(svc1);
+ ServiceDelegate svcDlg1 = DescriptionTestUtils2.getServiceDelegate(svc1);
+ assertNotNull(svcDlg1);
+ ServiceDescription svcDesc1 = svcDlg1.getServiceDescription();
+ assertNotNull(svcDesc1);
+
+ // Add a port to service, save off the metadata to validate later
+ svc1.addPort(new QName(namespaceURI, dynamicPort1),
+ bindingID1,
+ epr1);
+ assertEquals(1, getList(svc1.getPorts()).size());
+ Collection<?> epDesc1Collection =
+ ((ServiceDescriptionImpl) svcDesc1).getDynamicEndpointDescriptions_AsCollection(svcDlg1);
+ assertEquals("Wrong number of dynamic endpoints", 1, epDesc1Collection.size());
+ EndpointDescription epDescFirstAddPort = (EndpointDescription) epDesc1Collection.toArray()[0];
+
+ // Add the same port to the same service instance, should use the same description objects
+ svc1.addPort(new QName(namespaceURI, dynamicPort1),
+ bindingID1,
+ epr1);
+ assertEquals(1, getList(svc1.getPorts()).size());
+ // Make sure the EndpointDescription object is reused for second port.
+ Collection<?> epDesc2Collection =
+ ((ServiceDescriptionImpl) svcDesc1).getDynamicEndpointDescriptions_AsCollection(svcDlg1);
+ assertEquals("Wrong number of dynamic endpoints", 1, epDesc2Collection.size());
+
+ EndpointDescription epDescSecondAddPort = (EndpointDescription) epDesc1Collection.toArray()[0];
+ assertSame("EndpointDescriptions not reused", epDescFirstAddPort, epDescSecondAddPort);
+
+ } finally {
+ ClientMetadataTest.restoreOriginalFactory();
+ }
+
+ }
+ /**
+ * Validate that ports added to services with different service names (and thus different service instances)
+ * are not shared.
+ */
+ public void testSamePortsDifferentServiceNames() {
+ try {
+ ClientMetadataTest.installCachingFactory();
+ QName svcQN = new QName(namespaceURI, svcLocalPart);
+ Service svc1 = Service.create(svcQN);
+ assertNotNull(svc1);
+ ServiceDelegate svcDlg1 = DescriptionTestUtils2.getServiceDelegate(svc1);
+ assertNotNull(svcDlg1);
+ ServiceDescription svcDesc1 = svcDlg1.getServiceDescription();
+ assertNotNull(svcDesc1);
+
+ QName svcQN2 = new QName(namespaceURI, svcLocalPart + "2");
+ Service svc2 = Service.create(svcQN2);
+ assertNotNull(svc2);
+ ServiceDelegate svcDlg2 = DescriptionTestUtils2.getServiceDelegate(svc2);
+ assertNotNull(svcDlg2);
+ ServiceDescription svcDesc2 = svcDlg2.getServiceDescription();
+ assertNotNull(svcDesc2);
+
+ assertNotSame("Service instances should not be the same", svc1, svc2);
+ assertNotSame("Service delegates should not be the same", svcDlg1, svcDlg2);
+ assertNotSame("Instance of ServiceDescription should not be the same", svcDesc1, svcDesc2);
+
+ // Add a port to 1st service, should not be visible under the 2nd service
+ svc1.addPort(new QName(namespaceURI, dynamicPort1),
+ bindingID1,
+ epr1);
+ assertEquals(1, getList(svc1.getPorts()).size());
+ assertEquals(0, getList(svc2.getPorts()).size());
+
+ // Add the same port to 2nd service, should now have same ports and description
+ // objects
+ svc2.addPort(new QName(namespaceURI, dynamicPort1),
+ bindingID1,
+ epr1);
+ assertEquals(1, getList(svc1.getPorts()).size());
+ assertEquals(1, getList(svc2.getPorts()).size());
+
+ // Make sure the EndpointDescription objects are NOT shared.
+ Collection<?> epDesc1Collection =
+ ((ServiceDescriptionImpl) svcDesc1).getDynamicEndpointDescriptions_AsCollection(svcDlg1);
+ Collection<?> epDesc2Collection =
+ ((ServiceDescriptionImpl) svcDesc2).getDynamicEndpointDescriptions_AsCollection(svcDlg2);
+ assertEquals("Wrong number of dynamic endpoints", 1, epDesc1Collection.size());
+ assertEquals("Wrong number of dynamic endpoints", 1, epDesc2Collection.size());
+
+ EndpointDescription epDesc1 = (EndpointDescription) epDesc1Collection.toArray().clone()[0];
+ EndpointDescription epDesc2 = (EndpointDescription) epDesc2Collection.toArray().clone()[0];
+ assertNotSame("EndpointDescriptions should not be shared across different services", epDesc1, epDesc2);
} finally {
ClientMetadataTest.restoreOriginalFactory();
@@ -124,4 +391,17 @@ public class DynamicPortCachingTests ext
}
return returnList;
}
+
+ private void setAxisConfigParameter(Service service, String key, String value) {
+ ServiceDelegate delegate = DescriptionTestUtils2.getServiceDelegate(service);
+ ServiceDescription svcDesc = delegate.getServiceDescription();
+ AxisConfiguration axisConfig = svcDesc.getAxisConfigContext().getAxisConfiguration();
+ Parameter parameter = new Parameter(key, value);
+ try {
+ axisConfig.addParameter(parameter);
+ } catch (AxisFault e) {
+ fail("Unable to set Parameter on AxisConfig due to exception " + e);
+ }
+ }
+
}
\ No newline at end of file
Modified: axis/axis2/java/core/trunk/modules/metadata/src/org/apache/axis2/jaxws/description/builder/MDQConstants.java
URL: http://svn.apache.org/viewvc/axis/axis2/java/core/trunk/modules/metadata/src/org/apache/axis2/jaxws/description/builder/MDQConstants.java?rev=1068985&r1=1068984&r2=1068985&view=diff
==============================================================================
--- axis/axis2/java/core/trunk/modules/metadata/src/org/apache/axis2/jaxws/description/builder/MDQConstants.java (original)
+++ axis/axis2/java/core/trunk/modules/metadata/src/org/apache/axis2/jaxws/description/builder/MDQConstants.java Wed Feb 9 17:13:37 2011
@@ -97,4 +97,24 @@ public class MDQConstants {
public static final String USE_MANIFEST_LEGACY_WEB_METHOD_RULES = "LegacyWebMethod";
public static final String SUN_WEB_METHOD_BEHAVIOR_CHANGE_VERSION = "2.1.6";
+ /**
+ * Context Property:
+ * Name: jaxws.share.dynamic.ports.enable
+ * Value: String "false" or "true"
+ * Default: null, which is interpreted as "false"
+ * Can be set on:
+ * - Axis Configuration, which indicates that dynamic ports should be shared across services based on
+ * a key of (PortQName, BindingId, EndpointAddress)
+ *
+ * Dynamic ports, which are those created by Service.addPort(...), should only be visible to the instance
+ * of the service that did the addPort. However, for backwards compatibility, this flag can be used
+ * to enable the sharing of dynamic ports across all services on an AxisConfiguration based on the key
+ * (PortQName, BindingId, EndpointAddress).
+ *
+ * The default setting of this property is null, which is interpreted as "false", which will scope the
+ * visibility of dynamic ports to the instance of the service that did the addPort().
+ */
+ public static final String SHARE_DYNAMIC_PORTS_ACROSS_SERVICES = "jaxws.share.dynamic.ports.enable";
+
+
}
Modified: axis/axis2/java/core/trunk/modules/metadata/src/org/apache/axis2/jaxws/description/impl/ServiceDescriptionImpl.java
URL: http://svn.apache.org/viewvc/axis/axis2/java/core/trunk/modules/metadata/src/org/apache/axis2/jaxws/description/impl/ServiceDescriptionImpl.java?rev=1068985&r1=1068984&r2=1068985&view=diff
==============================================================================
--- axis/axis2/java/core/trunk/modules/metadata/src/org/apache/axis2/jaxws/description/impl/ServiceDescriptionImpl.java (original)
+++ axis/axis2/java/core/trunk/modules/metadata/src/org/apache/axis2/jaxws/description/impl/ServiceDescriptionImpl.java Wed Feb 9 17:13:37 2011
@@ -146,6 +146,14 @@ public class ServiceDescriptionImpl
// RUNTIME INFORMATION
Map<String, ServiceRuntimeDescription> runtimeDescMap =
new ConcurrentHashMap<String, ServiceRuntimeDescription>();
+
+ /**
+ * Property representing a collection of endpointDescription instances for dynamic ports
+ * which are shared across all services on an AxisConfig. Note that this behavior is incorrect; dynamic
+ * ports should only be visible to the instance of the service that created them. However, the sharing
+ * across services is maintained for backwards compatibility.
+ * @deprecated
+ */
private static final String JAXWS_DYNAMIC_ENDPOINTS = "jaxws.dynamic.endpoints";
/**
@@ -491,7 +499,7 @@ public class ServiceDescriptionImpl
Messages.getMessage("serviceDescriptionImplAddPortErr"));
}
- endpointDescription = createEndpointDescriptionImpl(sei, portQName, bindingId, endpointAddress);
+ endpointDescription = getDynamicEndpointDescriptionImpl(sei, portQName, bindingId, endpointAddress);
addDynamicEndpointDescriptionImpl(endpointDescription, serviceDelegateKey);
} else {
@@ -596,19 +604,104 @@ public class ServiceDescriptionImpl
return endpointDescription;
}
- private EndpointDescriptionImpl createEndpointDescriptionImpl(Class sei, QName portQName, String bindingId, String endpointAddress) {
+ /**
+ * Find or create an EndpointDescription instance for a dynamic port. Dynamic ports should be scoped to
+ * the instance of the service that created them, so the method getDynamicEndpointDescriptionImpl should
+ * have find one if it already exists. However, logic was introduced (in Apache Axis2 revision 664411) that
+ * also scoped dynamic ports to a configuration context based on port name, binding ID, and endpointAddress.
+ * Although that logic is incorrect, it is maintained for backwards compatability based on the setting of
+ * a property.
+ *
+ * @param sei
+ * @param portQName
+ * @param bindingId
+ * @param endpointAddress
+ * @return
+ */
+ private EndpointDescriptionImpl getDynamicEndpointDescriptionImpl(Class sei, QName portQName, String bindingId, String endpointAddress) {
if (log.isDebugEnabled()) {
log.debug("Calling createEndpointDescriptionImpl : ("
+ portQName + "," + bindingId + "," + endpointAddress + ")");
}
EndpointDescriptionImpl endpointDescription = null;
+ SharedDynamicEndpointEntry sharedDynamicEndpointEntry = null;
+ boolean areDynamicPortsShared = isShareDynamicPortsAcrossServicesEnabled();
+ if (areDynamicPortsShared) {
+ // If ports are being shared, see if there's already one in the cache. Note that this will
+ // always return an Entry value, but the endpoint in it may be null if one wasn't found.
+ sharedDynamicEndpointEntry = findSharedDynamicEndpoint(portQName, bindingId, endpointAddress);
+ endpointDescription = sharedDynamicEndpointEntry.endpointDescription;
+ }
+
+ boolean endpointCreated = false;
+ if(endpointDescription == null) {
+ endpointDescription = new EndpointDescriptionImpl(sei, portQName, true, this);
+ endpointCreated = true;
+ }
+ if (areDynamicPortsShared && endpointCreated) {
+ // If ports are being shared and a new endpoint was created, then it needs to be
+ // added to the cache. Note that the other values in the entry (the cache hashmap and
+ // the key) were set when we looked for the entry above.
+ sharedDynamicEndpointEntry.endpointDescription = endpointDescription;
+ cacheSharedDynamicPointEndpoint(sharedDynamicEndpointEntry);
+ }
+ return endpointDescription;
+ }
+
+ /**
+ * Add the EndpointDescriptionImpl representing the dynamic port to the cache of ports shared across
+ * services.
+ * @param sharedDynamicEndpointEntry Contains the EndpointDescriptionImpl instance and the key
+ * associated with to be added to the cache, which is also contained in the entry.
+ */
+ private void cacheSharedDynamicPointEndpoint(SharedDynamicEndpointEntry sharedDynamicEndpointEntry) {
+
+ HashMap cachedDescriptions = sharedDynamicEndpointEntry.cachedDescriptions;
+ String key = sharedDynamicEndpointEntry.key;
+ EndpointDescriptionImpl endpointDescription = sharedDynamicEndpointEntry.endpointDescription;
+
+ synchronized(cachedDescriptions) {
+ if (log.isDebugEnabled()) {
+ log.debug("Calling cachedDescriptions.put : ("
+ + key.toString() + ") : size - " + cachedDescriptions.size());
+ }
+ cachedDescriptions.put(key.toString(), new WeakReference(endpointDescription));
+ }
+ }
+
+ /**
+ * Look for an existing shared endpointDescriptionImpl instance corresponding to a dynamic port based on
+ * a key of(portQname, bindingId, endpointAddress). Note that sharing dynamic ports across services is
+ * disable by default, and must be enabled via a property. Dynamic ports, by default, should only be
+ * visible to the instance of the service that added them.
+ *
+ * Note that a SharedDynamicEntry will be returned whether or not an existing EndpointDescriptionImpl
+ * is found. If one is not found, then one needs to be created and then added to the cache. The information
+ * in the returned SharedDynamicEntry can be used to add it.
+ *
+ * @see #isShareDynamicPortsAcrossServicesEnabled()
+ * @see #cacheSharedDynamicPointEndpoint(SharedDynamicEndpointEntry)
+ * @see SharedDynamicEndpointEntry
+ * @see #getDynamicEndpointDescriptionImpl(QName, Object)
+ *
+ * @param portQName
+ * @param bindingId
+ * @param endpointAddress
+ * @return A non-null SharedDynamicEndpointEntry is always returned. The key and cachedDescriptions
+ * variables will always be set. If an existing endpoint is found, then endpointDescription will be non-null.
+ */
+ private SharedDynamicEndpointEntry findSharedDynamicEndpoint(QName portQName,
+ String bindingId, String endpointAddress) {
+
+ SharedDynamicEndpointEntry returnDynamicEntry = new SharedDynamicEndpointEntry();
+ EndpointDescriptionImpl sharedDynamicEndpoint = null;
+
AxisConfiguration configuration = configContext.getAxisConfiguration();
if (log.isDebugEnabled()) {
log.debug("looking for " + JAXWS_DYNAMIC_ENDPOINTS + " in AxisConfiguration : " + configuration);
}
Parameter parameter = configuration.getParameter(JAXWS_DYNAMIC_ENDPOINTS);
- HashMap cachedDescriptions = (HashMap)
- ((parameter == null) ? null : parameter.getValue());
+ HashMap cachedDescriptions = (HashMap)((parameter == null) ? null : parameter.getValue());
if(cachedDescriptions == null) {
cachedDescriptions = new HashMap();
try {
@@ -622,10 +715,10 @@ public class ServiceDescriptionImpl
} else {
if (log.isDebugEnabled()) {
log.debug("found old jaxws.dynamic.endpoints cache in AxisConfiguration (" + cachedDescriptions + ") with size : ("
- + cachedDescriptions.size() + ")");
+ + cachedDescriptions.size() + ")");
}
}
-
+
StringBuffer key = new StringBuffer();
key.append(portQName == null ? "NULL" : portQName.toString());
key.append(':');
@@ -635,27 +728,50 @@ public class ServiceDescriptionImpl
synchronized(cachedDescriptions) {
WeakReference ref = (WeakReference) cachedDescriptions.get(key.toString());
if (ref != null) {
- endpointDescription = (EndpointDescriptionImpl) ref.get();
- }
- }
- if(endpointDescription == null) {
- endpointDescription = new EndpointDescriptionImpl(sei, portQName, true, this);
- synchronized(cachedDescriptions) {
+ sharedDynamicEndpoint = (EndpointDescriptionImpl) ref.get();
if (log.isDebugEnabled()) {
- log.debug("Calling cachedDescriptions.put : ("
- + key.toString() + ") : size - " + cachedDescriptions.size());
+ log.debug("found old entry for endpointDescription in jaxws.dynamic.endpoints cache : ("
+ + cachedDescriptions.size() + ")");
}
- cachedDescriptions.put(key.toString(), new WeakReference(endpointDescription));
}
- } else {
- if (log.isDebugEnabled()) {
- log.debug("found old entry for endpointDescription in jaxws.dynamic.endpoints cache : ("
- + cachedDescriptions.size() + ")");
+ }
+
+ returnDynamicEntry.cachedDescriptions = cachedDescriptions;
+ returnDynamicEntry.key = key.toString();
+ returnDynamicEntry.endpointDescription = sharedDynamicEndpoint;
+
+ return returnDynamicEntry;
+ }
+
+ /**
+ * Answer if dynamic ports are to be shared across services. The default value is FALSE, but it
+ * can be configured by an AxisConfig property. Note that this can only be set via a config property
+ * and not via a request context property since the setting affects multiple services.
+ *
+ * @return true if dynamic ports are to be shared across services, false otherwise.
+ */
+ private boolean isShareDynamicPortsAcrossServicesEnabled() {
+ boolean resolutionEnabled = false;
+
+ // See if an AxisConfig property enables the sharing of dynamic ports
+ String flagValue = null;
+ AxisConfiguration axisConfig = getAxisConfigContext().getAxisConfiguration();
+ Parameter parameter = axisConfig.getParameter(MDQConstants.SHARE_DYNAMIC_PORTS_ACROSS_SERVICES);
+ if (parameter != null) {
+ flagValue = (String) parameter.getValue();
+ }
+
+ // If the property was set, check the value.
+ if (flagValue != null) {
+ if ("false".equalsIgnoreCase(flagValue)) {
+ resolutionEnabled = false;
+ } else if ("true".equalsIgnoreCase(flagValue)) {
+ resolutionEnabled = true;
}
}
- return endpointDescription;
+ return resolutionEnabled;
}
-
+
/**
* This method will get all properties that have been set on the DescriptionBuilderComposite
* instance. If the DBC represents an implementation class that references an SEI, the
@@ -3039,4 +3155,13 @@ public class ServiceDescriptionImpl
return responses;
}
+ /**
+ * Entry returned from looking for an endpointDescriptionImpl for a shared dynamic port, or to be used
+ * to add one that was created to the cache.
+ */
+ class SharedDynamicEndpointEntry {
+ String key;
+ EndpointDescriptionImpl endpointDescription;
+ HashMap cachedDescriptions;
+ }
}