From 3ea383bebfa128b5e39722abf352a340a45d37a5 Mon Sep 17 00:00:00 2001 From: David Blain Date: Tue, 31 Jan 2012 15:51:26 +0100 Subject: [PATCH] Initial commit --- .classpath | 19 + .project | 23 + .settings/org.eclipse.jdt.core.prefs | 5 + .settings/org.maven.ide.eclipse.prefs | 9 + MessageService-soapui-project.xml | 94 +++ ear/pom.xml | 105 +++ .../META-INF/weblogic-application.xml | 5 + ejb/pom.xml | 235 +++++++ .../main/java/be/dabla/domain/MessageEJB.java | 57 ++ .../be/dabla/domain/MessageMDBSender.java | 59 ++ .../main/java/be/dabla/mdb/MessageMDB.java | 80 +++ ejb/src/main/resources/META-INF/ejb-jar.xml | 3 + .../resources/META-INF/weblogic-ejb-jar.xml | 35 + .../java/be/dabla/domain/MessageEJBTest.java | 49 ++ .../org/apache/openejb/ClassLoaderUtil.java | 264 +++++++ .../org/apache/openejb/OpenEJBTestCase.java | 42 ++ .../java/org/dbunit/DBUnitFixtureLoader.java | 121 ++++ ejb/src/test/resources/META-INF/ejb-jar.xml | 3 + ejb/src/test/resources/fixtures/messages.xml | 4 + jar/pom.xml | 107 +++ .../main/java/be/dabla/domain/EJBLocal.java | 11 + .../java/be/dabla/domain/MessageEJBLocal.java | 13 + .../be/dabla/domain/MessageEJBRemote.java | 8 + .../dabla/domain/MessageMDBSenderLocal.java | 12 + .../dabla/domain/MessageMDBSenderRemote.java | 8 + jar/src/main/java/be/dabla/model/Message.java | 89 +++ .../validation/EntityTraversableResolver.java | 16 + .../EntityValidationEventListener.java | 37 + .../java/be/dabla/service/MessageService.java | 21 + .../dabla/service/MessageServiceClient.java | 50 ++ .../be/dabla/service/handler/Address.java | 115 +++ .../handler/WSAddressingClientHandler.java | 76 ++ jar/src/main/resources/META-INF/orm.xml | 35 + .../main/resources/META-INF/persistence.xml | 14 + .../test/java/be/dabla/model/MessageTest.java | 24 + .../be/dabla/service/MockMessageContext.java | 91 +++ .../dabla/service/MockSOAPMessageContext.java | 43 ++ .../be/dabla/service/handler/AddressTest.java | 29 + .../be/dabla/service/handler/MockAddress.java | 14 + .../WSAddressingClientHandlerTest.java | 35 + jar/src/test/resources/jndi.properties | 20 + jar/src/test/resources/logging.properties | 34 + pom.xml | 135 ++++ war/derby/db.lck | Bin 0 -> 38 bytes war/derby/log/log.ctrl | Bin 0 -> 48 bytes war/derby/log/log1.dat | Bin 0 -> 157577 bytes war/derby/log/logmirror.ctrl | Bin 0 -> 48 bytes war/derby/seg0/c10.dat | Bin 0 -> 8192 bytes war/derby/seg0/c101.dat | Bin 0 -> 8192 bytes war/derby/seg0/c111.dat | Bin 0 -> 8192 bytes war/derby/seg0/c121.dat | Bin 0 -> 8192 bytes war/derby/seg0/c130.dat | Bin 0 -> 8192 bytes war/derby/seg0/c141.dat | Bin 0 -> 8192 bytes war/derby/seg0/c150.dat | Bin 0 -> 8192 bytes war/derby/seg0/c161.dat | Bin 0 -> 8192 bytes war/derby/seg0/c171.dat | Bin 0 -> 8192 bytes war/derby/seg0/c180.dat | Bin 0 -> 32768 bytes war/derby/seg0/c191.dat | Bin 0 -> 16384 bytes war/derby/seg0/c1a1.dat | Bin 0 -> 8192 bytes war/derby/seg0/c1b1.dat | Bin 0 -> 16384 bytes war/derby/seg0/c1c0.dat | Bin 0 -> 8192 bytes war/derby/seg0/c1d1.dat | Bin 0 -> 8192 bytes war/derby/seg0/c1e0.dat | Bin 0 -> 8192 bytes war/derby/seg0/c1f1.dat | Bin 0 -> 8192 bytes war/derby/seg0/c20.dat | Bin 0 -> 28672 bytes war/derby/seg0/c200.dat | Bin 0 -> 8192 bytes war/derby/seg0/c211.dat | Bin 0 -> 8192 bytes war/derby/seg0/c221.dat | Bin 0 -> 8192 bytes war/derby/seg0/c230.dat | Bin 0 -> 212992 bytes war/derby/seg0/c241.dat | Bin 0 -> 8192 bytes war/derby/seg0/c251.dat | Bin 0 -> 16384 bytes war/derby/seg0/c260.dat | Bin 0 -> 8192 bytes war/derby/seg0/c271.dat | Bin 0 -> 8192 bytes war/derby/seg0/c281.dat | Bin 0 -> 8192 bytes war/derby/seg0/c290.dat | Bin 0 -> 8192 bytes war/derby/seg0/c2a1.dat | Bin 0 -> 8192 bytes war/derby/seg0/c2b1.dat | Bin 0 -> 8192 bytes war/derby/seg0/c2c1.dat | Bin 0 -> 8192 bytes war/derby/seg0/c2d0.dat | Bin 0 -> 8192 bytes war/derby/seg0/c2e1.dat | Bin 0 -> 8192 bytes war/derby/seg0/c2f0.dat | Bin 0 -> 8192 bytes war/derby/seg0/c300.dat | Bin 0 -> 8192 bytes war/derby/seg0/c31.dat | Bin 0 -> 8192 bytes war/derby/seg0/c311.dat | Bin 0 -> 8192 bytes war/derby/seg0/c321.dat | Bin 0 -> 8192 bytes war/derby/seg0/c331.dat | Bin 0 -> 8192 bytes war/derby/seg0/c340.dat | Bin 0 -> 8192 bytes war/derby/seg0/c351.dat | Bin 0 -> 8192 bytes war/derby/seg0/c361.dat | Bin 0 -> 8192 bytes war/derby/seg0/c371.dat | Bin 0 -> 8192 bytes war/derby/seg0/c380.dat | Bin 0 -> 8192 bytes war/derby/seg0/c391.dat | Bin 0 -> 8192 bytes war/derby/seg0/c3a1.dat | Bin 0 -> 8192 bytes war/derby/seg0/c3b1.dat | Bin 0 -> 8192 bytes war/derby/seg0/c3c0.dat | Bin 0 -> 8192 bytes war/derby/seg0/c3d1.dat | Bin 0 -> 8192 bytes war/derby/seg0/c3e1.dat | Bin 0 -> 8192 bytes war/derby/seg0/c3f1.dat | Bin 0 -> 8192 bytes war/derby/seg0/c41.dat | Bin 0 -> 16384 bytes war/derby/seg0/c4a0.dat | Bin 0 -> 8192 bytes war/derby/seg0/c4b1.dat | Bin 0 -> 8192 bytes war/derby/seg0/c51.dat | Bin 0 -> 8192 bytes war/derby/seg0/c60.dat | Bin 0 -> 12288 bytes war/derby/seg0/c71.dat | Bin 0 -> 8192 bytes war/derby/seg0/c81.dat | Bin 0 -> 8192 bytes war/derby/seg0/c90.dat | Bin 0 -> 24576 bytes war/derby/seg0/ca1.dat | Bin 0 -> 24576 bytes war/derby/seg0/cb1.dat | Bin 0 -> 8192 bytes war/derby/seg0/cc0.dat | Bin 0 -> 8192 bytes war/derby/seg0/cd1.dat | Bin 0 -> 8192 bytes war/derby/seg0/ce1.dat | Bin 0 -> 8192 bytes war/derby/seg0/cf0.dat | Bin 0 -> 8192 bytes war/derby/seg0/d480.dat | Bin 0 -> 4096 bytes war/derby/seg0/d491.dat | Bin 0 -> 4096 bytes war/derby/service.properties | 22 + war/pom.xml | 443 ++++++++++++ .../dabla/AbstractInitialContextProvider.java | 28 + .../model/AbstractPaginationController.java | 15 + .../be/dabla/model/MessageController.java | 13 + .../java/be/dabla/model/RepeatPaginator.java | 99 +++ .../AbstractAsynchronousWebService.java | 46 ++ .../service/impl/MessageServiceImpl.java | 54 ++ .../util/MessageContextAddressingHelper.java | 146 ++++ war/src/main/resources/env-entry.properties | 3 + war/src/main/resources/web.xml | 34 + .../main/resources/wsdl/MessageService.wsdl | 48 ++ .../resources/wsdl/MessageService_schema1.xsd | 30 + .../resources/wsdl/MessageService_schema2.xsd | 8 + war/src/main/webapp/WEB-INF/faces-config.xml | 17 + war/src/main/webapp/index.xhtml | 40 ++ war/src/main/webapp/resources/css/reset.css | 48 ++ war/src/main/webapp/templates/layout.xhtml | 19 + .../be/dabla/model/RequestControllerTest.java | 23 + .../be/dabla/service/MessageServiceTest.java | 29 + .../be/dabla/service/WebServiceTestCase.java | 63 ++ .../MessageContextAddressingHelperTest.java | 19 + .../java/be/dabla/servlet/CXFServlet.java | 114 +++ .../support/JaxWsServiceFactoryBean.java | 654 ++++++++++++++++++ war/src/test/resources/META-INF/ejb-jar.xml | 1 + war/src/test/resources/logging.properties | 34 + 140 files changed, 4299 insertions(+) create mode 100644 .classpath create mode 100644 .project create mode 100644 .settings/org.eclipse.jdt.core.prefs create mode 100644 .settings/org.maven.ide.eclipse.prefs create mode 100644 MessageService-soapui-project.xml create mode 100644 ear/pom.xml create mode 100644 ear/src/main/application/META-INF/weblogic-application.xml create mode 100644 ejb/pom.xml create mode 100644 ejb/src/main/java/be/dabla/domain/MessageEJB.java create mode 100644 ejb/src/main/java/be/dabla/domain/MessageMDBSender.java create mode 100644 ejb/src/main/java/be/dabla/mdb/MessageMDB.java create mode 100644 ejb/src/main/resources/META-INF/ejb-jar.xml create mode 100644 ejb/src/main/resources/META-INF/weblogic-ejb-jar.xml create mode 100644 ejb/src/test/java/be/dabla/domain/MessageEJBTest.java create mode 100644 ejb/src/test/java/org/apache/openejb/ClassLoaderUtil.java create mode 100644 ejb/src/test/java/org/apache/openejb/OpenEJBTestCase.java create mode 100644 ejb/src/test/java/org/dbunit/DBUnitFixtureLoader.java create mode 100644 ejb/src/test/resources/META-INF/ejb-jar.xml create mode 100644 ejb/src/test/resources/fixtures/messages.xml create mode 100644 jar/pom.xml create mode 100644 jar/src/main/java/be/dabla/domain/EJBLocal.java create mode 100644 jar/src/main/java/be/dabla/domain/MessageEJBLocal.java create mode 100644 jar/src/main/java/be/dabla/domain/MessageEJBRemote.java create mode 100644 jar/src/main/java/be/dabla/domain/MessageMDBSenderLocal.java create mode 100644 jar/src/main/java/be/dabla/domain/MessageMDBSenderRemote.java create mode 100644 jar/src/main/java/be/dabla/model/Message.java create mode 100644 jar/src/main/java/be/dabla/model/validation/EntityTraversableResolver.java create mode 100644 jar/src/main/java/be/dabla/model/validation/EntityValidationEventListener.java create mode 100644 jar/src/main/java/be/dabla/service/MessageService.java create mode 100644 jar/src/main/java/be/dabla/service/MessageServiceClient.java create mode 100644 jar/src/main/java/be/dabla/service/handler/Address.java create mode 100644 jar/src/main/java/be/dabla/service/handler/WSAddressingClientHandler.java create mode 100644 jar/src/main/resources/META-INF/orm.xml create mode 100644 jar/src/main/resources/META-INF/persistence.xml create mode 100644 jar/src/test/java/be/dabla/model/MessageTest.java create mode 100644 jar/src/test/java/be/dabla/service/MockMessageContext.java create mode 100644 jar/src/test/java/be/dabla/service/MockSOAPMessageContext.java create mode 100644 jar/src/test/java/be/dabla/service/handler/AddressTest.java create mode 100644 jar/src/test/java/be/dabla/service/handler/MockAddress.java create mode 100644 jar/src/test/java/be/dabla/service/handler/WSAddressingClientHandlerTest.java create mode 100644 jar/src/test/resources/jndi.properties create mode 100644 jar/src/test/resources/logging.properties create mode 100644 pom.xml create mode 100644 war/derby/db.lck create mode 100644 war/derby/log/log.ctrl create mode 100644 war/derby/log/log1.dat create mode 100644 war/derby/log/logmirror.ctrl create mode 100644 war/derby/seg0/c10.dat create mode 100644 war/derby/seg0/c101.dat create mode 100644 war/derby/seg0/c111.dat create mode 100644 war/derby/seg0/c121.dat create mode 100644 war/derby/seg0/c130.dat create mode 100644 war/derby/seg0/c141.dat create mode 100644 war/derby/seg0/c150.dat create mode 100644 war/derby/seg0/c161.dat create mode 100644 war/derby/seg0/c171.dat create mode 100644 war/derby/seg0/c180.dat create mode 100644 war/derby/seg0/c191.dat create mode 100644 war/derby/seg0/c1a1.dat create mode 100644 war/derby/seg0/c1b1.dat create mode 100644 war/derby/seg0/c1c0.dat create mode 100644 war/derby/seg0/c1d1.dat create mode 100644 war/derby/seg0/c1e0.dat create mode 100644 war/derby/seg0/c1f1.dat create mode 100644 war/derby/seg0/c20.dat create mode 100644 war/derby/seg0/c200.dat create mode 100644 war/derby/seg0/c211.dat create mode 100644 war/derby/seg0/c221.dat create mode 100644 war/derby/seg0/c230.dat create mode 100644 war/derby/seg0/c241.dat create mode 100644 war/derby/seg0/c251.dat create mode 100644 war/derby/seg0/c260.dat create mode 100644 war/derby/seg0/c271.dat create mode 100644 war/derby/seg0/c281.dat create mode 100644 war/derby/seg0/c290.dat create mode 100644 war/derby/seg0/c2a1.dat create mode 100644 war/derby/seg0/c2b1.dat create mode 100644 war/derby/seg0/c2c1.dat create mode 100644 war/derby/seg0/c2d0.dat create mode 100644 war/derby/seg0/c2e1.dat create mode 100644 war/derby/seg0/c2f0.dat create mode 100644 war/derby/seg0/c300.dat create mode 100644 war/derby/seg0/c31.dat create mode 100644 war/derby/seg0/c311.dat create mode 100644 war/derby/seg0/c321.dat create mode 100644 war/derby/seg0/c331.dat create mode 100644 war/derby/seg0/c340.dat create mode 100644 war/derby/seg0/c351.dat create mode 100644 war/derby/seg0/c361.dat create mode 100644 war/derby/seg0/c371.dat create mode 100644 war/derby/seg0/c380.dat create mode 100644 war/derby/seg0/c391.dat create mode 100644 war/derby/seg0/c3a1.dat create mode 100644 war/derby/seg0/c3b1.dat create mode 100644 war/derby/seg0/c3c0.dat create mode 100644 war/derby/seg0/c3d1.dat create mode 100644 war/derby/seg0/c3e1.dat create mode 100644 war/derby/seg0/c3f1.dat create mode 100644 war/derby/seg0/c41.dat create mode 100644 war/derby/seg0/c4a0.dat create mode 100644 war/derby/seg0/c4b1.dat create mode 100644 war/derby/seg0/c51.dat create mode 100644 war/derby/seg0/c60.dat create mode 100644 war/derby/seg0/c71.dat create mode 100644 war/derby/seg0/c81.dat create mode 100644 war/derby/seg0/c90.dat create mode 100644 war/derby/seg0/ca1.dat create mode 100644 war/derby/seg0/cb1.dat create mode 100644 war/derby/seg0/cc0.dat create mode 100644 war/derby/seg0/cd1.dat create mode 100644 war/derby/seg0/ce1.dat create mode 100644 war/derby/seg0/cf0.dat create mode 100644 war/derby/seg0/d480.dat create mode 100644 war/derby/seg0/d491.dat create mode 100644 war/derby/service.properties create mode 100644 war/pom.xml create mode 100644 war/src/main/java/be/dabla/AbstractInitialContextProvider.java create mode 100644 war/src/main/java/be/dabla/model/AbstractPaginationController.java create mode 100644 war/src/main/java/be/dabla/model/MessageController.java create mode 100644 war/src/main/java/be/dabla/model/RepeatPaginator.java create mode 100644 war/src/main/java/be/dabla/service/AbstractAsynchronousWebService.java create mode 100644 war/src/main/java/be/dabla/service/impl/MessageServiceImpl.java create mode 100644 war/src/main/java/be/dabla/service/util/MessageContextAddressingHelper.java create mode 100644 war/src/main/resources/env-entry.properties create mode 100644 war/src/main/resources/web.xml create mode 100644 war/src/main/resources/wsdl/MessageService.wsdl create mode 100644 war/src/main/resources/wsdl/MessageService_schema1.xsd create mode 100644 war/src/main/resources/wsdl/MessageService_schema2.xsd create mode 100644 war/src/main/webapp/WEB-INF/faces-config.xml create mode 100644 war/src/main/webapp/index.xhtml create mode 100644 war/src/main/webapp/resources/css/reset.css create mode 100644 war/src/main/webapp/templates/layout.xhtml create mode 100644 war/src/test/java/be/dabla/model/RequestControllerTest.java create mode 100644 war/src/test/java/be/dabla/service/MessageServiceTest.java create mode 100644 war/src/test/java/be/dabla/service/WebServiceTestCase.java create mode 100644 war/src/test/java/be/dabla/service/util/MessageContextAddressingHelperTest.java create mode 100644 war/src/test/java/be/dabla/servlet/CXFServlet.java create mode 100644 war/src/test/java/org/apache/cxf/jaxws/support/JaxWsServiceFactoryBean.java create mode 100644 war/src/test/resources/META-INF/ejb-jar.xml create mode 100644 war/src/test/resources/logging.properties diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..29fcbb0 --- /dev/null +++ b/.classpath @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/.project b/.project new file mode 100644 index 0000000..335c27d --- /dev/null +++ b/.project @@ -0,0 +1,23 @@ + + + tomee-maven-demo + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.maven.ide.eclipse.maven2Builder + + + + + + org.maven.ide.eclipse.maven2Nature + org.eclipse.jdt.core.javanature + + diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..fef2bd7 --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,5 @@ +#Fri Jan 27 15:43:49 CET 2012 +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 +org.eclipse.jdt.core.compiler.compliance=1.6 +org.eclipse.jdt.core.compiler.source=1.6 diff --git a/.settings/org.maven.ide.eclipse.prefs b/.settings/org.maven.ide.eclipse.prefs new file mode 100644 index 0000000..6434337 --- /dev/null +++ b/.settings/org.maven.ide.eclipse.prefs @@ -0,0 +1,9 @@ +#Tue Jan 31 10:56:54 CET 2012 +activeProfiles= +eclipse.preferences.version=1 +fullBuildGoals=process-test-resources +includeModules=true +resolveWorkspaceProjects=true +resourceFilterGoals=process-resources resources\:testResources +skipCompilerPlugin=true +version=1 diff --git a/MessageService-soapui-project.xml b/MessageService-soapui-project.xml new file mode 100644 index 0000000..24dfb5e --- /dev/null +++ b/MessageService-soapui-project.xml @@ -0,0 +1,94 @@ + +http://localhost:8081/tomee-maven-demo-war-2.0.0/services/MessageService?wsdl + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +]]>http://schemas.xmlsoap.org/wsdl/http://localhost:8081/tomee-maven-demo-war-2.0.0/services/MessageServiceUTF-8http://localhost:8081/tomee-maven-demo-war-2.0.0/services/MessageService + + + + + + ? + ? + ? + + + +]]><xml-fragment/>UTF-8http://localhost:8081/tomee-maven-demo-war-2.0.0/services/MessageService + + + + + + Hello David + + + +]]>falseSEQUENCEResponse 1 \ No newline at end of file diff --git a/ear/pom.xml b/ear/pom.xml new file mode 100644 index 0000000..7437480 --- /dev/null +++ b/ear/pom.xml @@ -0,0 +1,105 @@ + + + + 4.0.0 + + + be.dabla + tomee-maven-demo + 2.0.0 + + + tomee-maven-demo-ear + ear + tomee-maven-demo-ear + + + + be.dabla + tomee-maven-demo-war + ${project.version} + war + + + be.dabla + tomee-maven-demo-ejb + ${project.version} + ejb + + + be.dabla + tomee-maven-demo-jar + ${project.version} + + + + javax.validation + validation-api + 1.0.0.GA + + + org.hibernate + hibernate-validator + 4.0.2.GA + + + org.slf4j + slf4j-api + 1.6.1 + + + + + + + org.apache.maven.plugins + maven-ear-plugin + 2.6 + + true + APP-INF/lib + tomee-maven-demo-ear + TomEE Maven Demo + 5 + + + ${project.version} + + + + + be.dabla + tomee-maven-demo-war + tomee-maven-demo-context-root + web.xml + + + be.dabla + tomee-maven-demo-ejb + + + javax.activation + activation + true + + + javax.xml.bind + jaxb-api + true + + + com.sun.xml.bind + jaxb-impl + true + + + javax.xml.stream + stax-api + true + + + + + + + \ No newline at end of file diff --git a/ear/src/main/application/META-INF/weblogic-application.xml b/ear/src/main/application/META-INF/weblogic-application.xml new file mode 100644 index 0000000..c3d876f --- /dev/null +++ b/ear/src/main/application/META-INF/weblogic-application.xml @@ -0,0 +1,5 @@ + + + \ No newline at end of file diff --git a/ejb/pom.xml b/ejb/pom.xml new file mode 100644 index 0000000..4266ced --- /dev/null +++ b/ejb/pom.xml @@ -0,0 +1,235 @@ + + + + 4.0.0 + + + be.dabla + tomee-maven-demo + 2.0.0 + + + tomee-maven-demo-ejb + ejb + tomee-maven-demo-ejb + + + + be.dabla + tomee-maven-demo-jar + ${project.version} + provided + + + org.eclipse.persistence + eclipselink + 1.1.0 + provided + + + junit + junit + 4.8.2 + test + + + org.apache.derby + derby + 10.4.2.0 + test + + + org.dbunit + dbunit + 2.4.5 + test + + + org.apache.activemq + activemq-core + 5.2.0 + test + + + org.apache.openejb + openejb-cxf + 3.1.4 + test + + + org.hibernate + hibernate-validator + 4.0.2.GA + test + + + org.slf4j + slf4j-api + 1.6.1 + test + + + be.dabla + tomee-maven-demo-jar + ${project.version} + test + tests + + + javax.validation + validation-api + 1.0.0.GA + provided + + + + javax.ejb + ejb-api + 3.0 + provided + + + javaee + javaee-api + 5 + provided + + + + + + + src/test/resources + true + + + + + org.apache.maven.plugins + maven-ejb-plugin + 2.3 + + 3.0 + + + + org.apache.maven.plugins + maven-jar-plugin + + + test-jar + + test-jar + + + + META-INF/*-jar.xml + jndi.properties + logging.properties + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + + pertest + -javaagent:${basedir}/target/openejb-javaagent-3.1.4.jar + ${basedir}/target + + + + + org.apache.maven.plugins + maven-dependency-plugin + + + process-resources + + copy + + + + + org.apache.openejb + openejb-javaagent + 3.1.4 + ${project.build.directory} + + + javax + javaee-endorsed-api + 6.0 + jar + + + + + + + + org.apache.maven.plugins + maven-resources-plugin + + + process-test-resources + + copy-resources + + + ${basedir}/target/test-classes/META-INF + + + src/main/resources/META-INF + + persistence.xml + orm.xml + + + + + + + + + + + + + default + + true + + + + + src/main/resources + true + + + + + + tomcat + + + + src/main/resources + true + + **/*ejb*.xml + + + + + + + \ No newline at end of file diff --git a/ejb/src/main/java/be/dabla/domain/MessageEJB.java b/ejb/src/main/java/be/dabla/domain/MessageEJB.java new file mode 100644 index 0000000..392ebcb --- /dev/null +++ b/ejb/src/main/java/be/dabla/domain/MessageEJB.java @@ -0,0 +1,57 @@ +package be.dabla.domain; + +import java.util.List; + +import javax.ejb.Remote; +import javax.ejb.Stateless; +import javax.persistence.EntityManager; +import javax.persistence.PersistenceContext; + +import be.dabla.model.Message; + +@Stateless(name="MessageEJB",mappedName="MessageEJB") +@Remote(MessageEJBRemote.class) +public class MessageEJB implements MessageEJBLocal { + @PersistenceContext(unitName = "tomee-maven-demo-pu") + protected EntityManager em; + + @Override + public Number count() { + return (Number)em.createQuery("SELECT COUNT(m.id) FROM Message m").getSingleResult(); + } + + @Override + public List findAll(int start, int size) { + return em.createNamedQuery("Message.findAll").setFirstResult(start).setMaxResults(size).getResultList(); + } + + @Override + public Message findById(final Long id) { + return em.find(Message.class, id); + } + + @Override + public Message create(final Message entity) { + if (entity != null) { + em.persist(entity); + } + + return entity; + } + + @Override + public void delete(final Message entity) { + if (entity != null) { + em.remove(em.merge(entity)); + } + } + + @Override + public Message update(final Message entity) { + if (entity != null) { + return em.merge(entity); + } + + return entity; + } +} \ No newline at end of file diff --git a/ejb/src/main/java/be/dabla/domain/MessageMDBSender.java b/ejb/src/main/java/be/dabla/domain/MessageMDBSender.java new file mode 100644 index 0000000..90a35a3 --- /dev/null +++ b/ejb/src/main/java/be/dabla/domain/MessageMDBSender.java @@ -0,0 +1,59 @@ +package be.dabla.domain; + +import java.util.logging.Level; +import java.util.logging.Logger; + +import javax.annotation.Resource; +import javax.ejb.Remote; +import javax.ejb.Stateless; +import javax.jms.Connection; +import javax.jms.ConnectionFactory; +import javax.jms.JMSException; +import javax.jms.MessageProducer; +import javax.jms.ObjectMessage; +import javax.jms.Queue; +import javax.jms.Session; + +import be.dabla.model.Message; +import be.dabla.service.handler.Address; + +@Stateless(name="MessageMDBSender",mappedName="MessageMDBSender") +@Remote(MessageMDBSenderRemote.class) +public class MessageMDBSender implements MessageMDBSenderRemote { + public static final int TIME_TO_LIVE = 120000; // set expiration time to 2 minutes + private static final Logger logger = Logger.getLogger(MessageMDBSender.class.getName()); + @Resource(mappedName="jms/tomee-maven-demo-cf") + ConnectionFactory connectionFactory; + @Resource(mappedName="jms/tomee-maven-demo-q") + Queue queue; + + public void sendMessage(final Address address) throws JMSException { + logger.log(Level.INFO, "sendMessage: {0}", address); + + Connection connection = null; + Session session = null; + + try { + connection = connectionFactory.createConnection(); + connection.start(); + session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE); + final MessageProducer producer = session.createProducer(queue); + producer.setTimeToLive(TIME_TO_LIVE); + final ObjectMessage message = session.createObjectMessage(address); + producer.send(message); + + logger.log(Level.FINE, "Message {0} send...", message); + } + finally { + try { + if (session != null) { + session.close(); + } + } finally { + if (connection != null) { + connection.close(); + } + } + } + } +} \ No newline at end of file diff --git a/ejb/src/main/java/be/dabla/mdb/MessageMDB.java b/ejb/src/main/java/be/dabla/mdb/MessageMDB.java new file mode 100644 index 0000000..761cf29 --- /dev/null +++ b/ejb/src/main/java/be/dabla/mdb/MessageMDB.java @@ -0,0 +1,80 @@ +package be.dabla.mdb; + +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Level; +import java.util.logging.Logger; + +import javax.ejb.ActivationConfigProperty; +import javax.ejb.EJB; +import javax.ejb.MessageDriven; +import javax.jms.MessageListener; +import javax.jms.ObjectMessage; +import javax.xml.ws.BindingProvider; +import javax.xml.ws.handler.Handler; +import javax.xml.ws.soap.SOAPFaultException; + +import be.dabla.domain.MessageEJBRemote; +import be.dabla.model.Message; +import be.dabla.service.MessageService; +import be.dabla.service.MessageServiceClient; +import be.dabla.service.handler.Address; +import be.dabla.service.handler.WSAddressingClientHandler; + +// http://download.oracle.com/javaee/6/tutorial/doc/gipvi.html (jee6/ejb3.1 would make it a lot easier) +@MessageDriven(mappedName = "jms/tomee-maven-demo-q", activationConfig = { + @ActivationConfigProperty(propertyName="destinationType",propertyValue="javax.jms.Queue"), + @ActivationConfigProperty(propertyName="destination",propertyValue="jms/tomee-maven-demo-q") +}) +public class MessageMDB implements MessageListener { + private static final Logger logger = Logger.getLogger(MessageMDB.class.getName()); + final WSAddressingClientHandler handler; + final MessageService port; + + public MessageMDB() { + handler = new WSAddressingClientHandler(); + final List handlerChain = new ArrayList(); + handlerChain.add(handler); + + port = new MessageServiceClient().getMessageService(); + ((BindingProvider)port).getBinding().setHandlerChain(handlerChain); + } + + @EJB + MessageEJBRemote ejb; + + @Override + public void onMessage(final javax.jms.Message msg) { + logger.log(Level.INFO, "onMessage: {0}", msg); + + try { + final Address address = (Address)((ObjectMessage)msg).getObject(); + + logger.log(Level.FINE, "address: {0}", address); + + if (address != null) { + final Message message = ejb.create(address.getContent()); + + logger.log(Level.FINE, "message: {0}", message); + + if (message != null) { + handler.setAddress(address); + ((BindingProvider)port).getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, address.getReplyTo()); + port.callbackMessage(message); + + logger.log(Level.INFO, "Message with id {0} acknowledged...", message.getId()); + } + else { + throw new Exception("Address doesn't contain a message!"); + } + } + } + catch(SOAPFaultException e) { + logger.warning(e.toString()); + } + catch(Exception e) { + logger.severe(e.toString()); + throw new RuntimeException(e); + } + } +} \ No newline at end of file diff --git a/ejb/src/main/resources/META-INF/ejb-jar.xml b/ejb/src/main/resources/META-INF/ejb-jar.xml new file mode 100644 index 0000000..446dae7 --- /dev/null +++ b/ejb/src/main/resources/META-INF/ejb-jar.xml @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/ejb/src/main/resources/META-INF/weblogic-ejb-jar.xml b/ejb/src/main/resources/META-INF/weblogic-ejb-jar.xml new file mode 100644 index 0000000..60348a5 --- /dev/null +++ b/ejb/src/main/resources/META-INF/weblogic-ejb-jar.xml @@ -0,0 +1,35 @@ + + + + MessageEJB + + + be.dabla.domain.MessageEJBRemote + MessageEJB + + + true + + + MessageMDBSender + + + be.dabla.domain.MessageMDBSenderRemote + MessageMDBSender + + + true + + + MessageMDB + + + 1 + 1 + + jms/tomee-maven-demo-q + jms/tomee-maven-demo-cf + + + \ No newline at end of file diff --git a/ejb/src/test/java/be/dabla/domain/MessageEJBTest.java b/ejb/src/test/java/be/dabla/domain/MessageEJBTest.java new file mode 100644 index 0000000..97416f5 --- /dev/null +++ b/ejb/src/test/java/be/dabla/domain/MessageEJBTest.java @@ -0,0 +1,49 @@ +package be.dabla.domain; + +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.fail; + +import javax.ejb.EJB; +import javax.naming.NamingException; + +import org.apache.openejb.OpenEJBTestCase; +import org.apache.openejb.api.LocalClient; +import org.junit.Test; + +import be.dabla.domain.MessageEJB; +import be.dabla.domain.MessageEJBRemote; +import be.dabla.model.Message; + +@LocalClient +public class MessageEJBTest extends OpenEJBTestCase { + @EJB + private MessageEJBRemote ejb; + + @Test + public void testCreate() { + assertNull(ejb.create(null)); + + try { + ejb.create(new Message()); // NOT NULL + fail("org.eclipse.persistence.exceptions.DatabaseException"); + } + catch(Exception e) { + + } + + assertNotNull(ejb.create(new Message("Hello World"))); + assertNotNull(ejb.create(new Message("Hello David"))); + } + + @Test + public void testCount() throws NamingException { + assertNotNull(ejb.count()); + } + + @Test + public void testFindAll() throws NamingException { + assertNotNull(initialContext.lookup(MessageEJB.class.getSimpleName())); + assertNotNull(ejb.findAll(0, 10)); + } +} \ No newline at end of file diff --git a/ejb/src/test/java/org/apache/openejb/ClassLoaderUtil.java b/ejb/src/test/java/org/apache/openejb/ClassLoaderUtil.java new file mode 100644 index 0000000..f1c4adb --- /dev/null +++ b/ejb/src/test/java/org/apache/openejb/ClassLoaderUtil.java @@ -0,0 +1,264 @@ +/** + * + * 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.openejb; + +import java.beans.Introspector; +import java.io.File; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.ObjectStreamClass; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.net.URL; +import java.net.URLClassLoader; +import java.security.AccessController; +import java.security.PrivilegedAction; +import java.util.ArrayList; +import java.util.Collections; +import java.util.ConcurrentModificationException; +import java.util.HashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.jar.JarFile; + +import org.apache.openejb.core.TempClassLoader; +import org.apache.openejb.util.LogCategory; +import org.apache.openejb.util.Logger; +import org.apache.openejb.util.UrlCache; + +/** + * @version $Revision: 948987 $ $Date: 2010-05-27 13:55:12 -0700 (Thu, 27 May 2010) $ + */ +public class ClassLoaderUtil { + private static final Logger logger = Logger.getInstance(LogCategory.OPENEJB, ClassLoaderUtil.class); + private static final Map> classLoadersByApp = new HashMap>(); + private static final Map> appsByClassLoader = new HashMap>(); + + private static final UrlCache urlCache = new UrlCache(); + + public static ClassLoader getContextClassLoader() { + return AccessController.doPrivileged(new PrivilegedAction() { + public ClassLoader run() { + return Thread.currentThread().getContextClassLoader(); + } + }); + } + + public static URLClassLoader createClassLoader(String appId, URL[] urls, ClassLoader parent) { + urls = urlCache.cacheUrls(appId, urls); + URLClassLoader classLoader = new URLClassLoader(urls, parent); + + List classLoaders = classLoadersByApp.get(appId); + if (classLoaders == null) { + classLoaders = new ArrayList(2); + classLoadersByApp.put(appId, classLoaders); + } + classLoaders.add(classLoader); + + Set apps = appsByClassLoader.get(classLoader); + if (apps == null) { + apps = new LinkedHashSet(1); + appsByClassLoader.put(classLoader, apps); + } + apps.add(appId); + + return classLoader; + } + + public static void destroyClassLoader(ClassLoader classLoader) { + logger.debug("Destroying classLoader " + toString(classLoader)); + + // remove from the indexes + Set apps = appsByClassLoader.remove(classLoader); + if (apps != null) { + for (String appId : apps) { + List classLoaders = classLoadersByApp.get(appId); + if (classLoaders != null) { + classLoaders.remove(classLoader); + // if this is the last class loader in the app, clean up the app + if (classLoaders.isEmpty()) { + destroyClassLoader(appId); + } + } + } + } + + // clear the lame openjpa caches + cleanOpenJPACache(classLoader); + } + + public static void destroyClassLoader(String appId) { + logger.debug("Destroying classLoaders for application " + appId); + + List classLoaders = classLoadersByApp.remove(appId); + if (classLoaders != null) { + for (ClassLoader classLoader : classLoaders) { + // get the apps using the class loader + Set apps = appsByClassLoader.get(classLoader); + if (apps == null) apps = Collections.emptySet(); + + // this app is no longer using the class loader + apps.remove(appId); + + // if no apps are using the class loader, destroy it + if (apps.isEmpty()) { + appsByClassLoader.remove(classLoader); + destroyClassLoader(classLoader); + } else { + logger.debug("ClassLoader " + toString(classLoader) + " held open by the applications" + apps); + } + } + } + urlCache.releaseUrls(appId); + clearSunJarFileFactoryCache(appId); + } + + public static URLClassLoader createTempClassLoader(ClassLoader parent) { + return new TempClassLoader(parent); + } + + public static URLClassLoader createTempClassLoader(String appId, URL[] urls, ClassLoader parent) { + URLClassLoader classLoader = createClassLoader(appId, urls, parent); + TempClassLoader tempClassLoader = new TempClassLoader(classLoader); + return tempClassLoader; + } + + /** + * Cleans well known class loader leaks in VMs and libraries. There is a lot of bad code out there and this method + * will clear up the know problems. This method should only be called when the class loader will no longer be used. + * It this method is called two often it can have a serious impact on preformance. + */ + public static void clearClassLoaderCaches() { + clearSunSoftCache(ObjectInputStream.class, "subclassAudits"); + clearSunSoftCache(ObjectOutputStream.class, "subclassAudits"); + clearSunSoftCache(ObjectStreamClass.class, "localDescs"); + clearSunSoftCache(ObjectStreamClass.class, "reflectors"); + Introspector.flushCaches(); + } + + public static void clearSunJarFileFactoryCache(final String jarLocation) { + clearSunJarFileFactoryCacheImpl(jarLocation, 5); + } + + private static void clearSunJarFileFactoryCacheImpl(final String jarLocation, final int attempt) { + logger.debug("Clearing Sun JarFileFactory cache for directory " + jarLocation); + + try { + Class jarFileFactory = Class.forName("sun.net.www.protocol.jar.JarFileFactory"); + + synchronized (jarFileFactory) { + + Field fileCacheField = jarFileFactory.getDeclaredField("fileCache"); + + fileCacheField.setAccessible(true); + Map fileCache = (Map) fileCacheField.get(null); + + Field urlCacheField = jarFileFactory.getDeclaredField("urlCache"); + urlCacheField.setAccessible(true); + + Map ucf = (Map) urlCacheField.get(null); + + List removedKeys = new ArrayList(); + for (Map.Entry entry : fileCache.entrySet()) { + if (isParent(jarLocation, new File(entry.getValue().getName()))) { + removedKeys.add(entry.getKey()); + } + } + + for(Object key : removedKeys) { + JarFile jarFile = fileCache.remove(key); + if(jarFile != null) { + ucf.remove(jarFile); + try { + jarFile.close(); + } catch (Throwable e) { + //Ignore + } + } + } + } + } catch (ConcurrentModificationException e) { + if (attempt > 0) { + clearSunJarFileFactoryCacheImpl(jarLocation, (attempt - 1)); + } else { + logger.error("Unable to clear Sun JarFileFactory cache after 5 attempts", e); + } + } catch (ClassNotFoundException e) { + // not a sun vm + } catch (NoSuchFieldException e) { + // different version of sun vm? + } catch (Throwable e) { + logger.error("Unable to clear Sun JarFileFactory cache", e); + } + } + + private static boolean isParent(String jarLocation, File file) { + File dir = new File(jarLocation); + while (file != null) { + if (file.equals(dir)) { + return true; + } + file = file.getParentFile(); + } + return false; + } + + /** + * Clears the caches maintained by the SunVM object stream implementation. This method uses reflection and + * setAccessable to obtain access to the Sun cache. The cache is locked with a synchronize monitor and cleared. + * This method completely clears the class loader cache which will impact preformance of object serialization. + * @param clazz the name of the class containing the cache field + * @param fieldName the name of the cache field + */ + public static void clearSunSoftCache(Class clazz, String fieldName) { + Map cache = null; + try { + Field field = clazz.getDeclaredField(fieldName); + field.setAccessible(true); + cache = (Map) field.get(null); + } catch (Throwable ignored) { + // there is nothing a user could do about this anyway + } + + if (cache != null) { + synchronized (cache) { + cache.clear(); + } + } + } + + public static void cleanOpenJPACache(ClassLoader classLoader) { + try { + Class pcRegistryClass = ClassLoaderUtil.class.getClassLoader().loadClass("org.apache.openjpa.enhance.PCRegistry"); + Method deRegisterMethod = pcRegistryClass.getMethod("deRegister", ClassLoader.class); + deRegisterMethod.invoke(null, classLoader); + } catch (Throwable ignored) { + // there is nothing a user could do about this anyway + } + } + + private static String toString(ClassLoader classLoader) { + if (classLoader == null) { + return "null"; + } else { + return classLoader.getClass().getSimpleName() + "@" + System.identityHashCode(classLoader); + } + } +} \ No newline at end of file diff --git a/ejb/src/test/java/org/apache/openejb/OpenEJBTestCase.java b/ejb/src/test/java/org/apache/openejb/OpenEJBTestCase.java new file mode 100644 index 0000000..1a53d82 --- /dev/null +++ b/ejb/src/test/java/org/apache/openejb/OpenEJBTestCase.java @@ -0,0 +1,42 @@ +package org.apache.openejb; + +import java.util.Properties; + +import javax.naming.InitialContext; +import javax.persistence.EntityManager; +import javax.persistence.PersistenceContext; +import javax.transaction.UserTransaction; + +import org.dbunit.DBUnitFixtureLoader; +import org.junit.After; +import org.junit.Before; + +public abstract class OpenEJBTestCase { + protected static final InitialContext initialContext; + + @PersistenceContext(unitName = "tomee-maven-demo-pu") + protected EntityManager em; + + static { + final Properties properties = new Properties(); + + try { + properties.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("jndi.properties")); + initialContext = new InitialContext(properties); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + @Before + public void setUp() throws Exception { + initialContext.bind("inject", this); + + new DBUnitFixtureLoader((UserTransaction)initialContext.lookup("java:comp/UserTransaction"), em).load(); + } + + @After + public void tearDown() throws Exception { + initialContext.unbind("inject"); + } +} \ No newline at end of file diff --git a/ejb/src/test/java/org/dbunit/DBUnitFixtureLoader.java b/ejb/src/test/java/org/dbunit/DBUnitFixtureLoader.java new file mode 100644 index 0000000..b7c3889 --- /dev/null +++ b/ejb/src/test/java/org/dbunit/DBUnitFixtureLoader.java @@ -0,0 +1,121 @@ +package org.dbunit; + +import java.io.BufferedReader; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.StringReader; + +import java.security.CodeSource; +import java.sql.Connection; +import java.sql.SQLException; +import java.util.Properties; +import java.util.logging.Level; +import java.util.logging.Logger; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; + +import javax.persistence.EntityManager; +import javax.transaction.UserTransaction; + +import org.dbunit.database.DatabaseConnection; +import org.dbunit.dataset.DataSetException; +import org.dbunit.dataset.ReplacementDataSet; +import org.dbunit.dataset.xml.FlatXmlDataSet; +import org.dbunit.operation.DatabaseOperation; +import org.eclipse.persistence.internal.jpa.EntityManagerImpl; +import org.eclipse.persistence.sessions.DatabaseLogin; +import org.eclipse.persistence.sessions.server.ServerSession; +import org.xml.sax.InputSource; + +public class DBUnitFixtureLoader { + + private static final Logger logger = Logger.getLogger(DBUnitFixtureLoader.class.getName()); + private UserTransaction tx; + private EntityManager em; + + public DBUnitFixtureLoader(final UserTransaction tx, final EntityManager em) { + this.tx = tx; + this.em = em; + } + + public void load() throws Exception { + if (tx != null) { + try { + tx.begin(); //start a new transaction + + // http://www.antoniogoncalves.org/xwiki/bin/view/Article/TestingJPA + // http://forums.oracle.com/forums/thread.jspa?threadID=525646 + final ServerSession session = ((EntityManagerImpl) (em.getDelegate())).getServerSession(); + final DatabaseLogin login = session.getLogin(); + final Connection connection = (Connection) login.connectToDatasource(session.getAccessor(), session); + + try { + final Properties properties = new Properties(); + properties.load(getClass().getClassLoader().getResourceAsStream("fixtures")); + + if (!properties.isEmpty()){ + for (final Object resource : properties.keySet()) { + final String name = "fixtures/" + resource; + logger.log(Level.INFO, "Adding fixture ''{0}''", name); + + append(connection, new FlatXmlDataSet(getClass().getClassLoader().getResourceAsStream(name))); + } + } + } + catch(NullPointerException e) { + final CodeSource src = getClass().getProtectionDomain().getCodeSource(); + + System.out.println("CodeSource: " + src); + + if (src != null) { + ZipInputStream zip = null; + ZipEntry entry = null; + + try { + zip = new ZipInputStream(src.getLocation().openStream()); + + // + // Read each entry from the ZipInputStream until no more entry found + // indicated by a null return value of the getNextEntry() method. + // + while ((entry = zip.getNextEntry()) != null) { + if (!entry.isDirectory() && (entry.getName().indexOf("fixture") > -1) && entry.getName().endsWith(".xml")) { + logger.log(Level.INFO, "Adding fixture ''{0}''", entry.getName()); + int size; + final byte[] buffer = new byte[2048]; + final ByteArrayOutputStream bos = new ByteArrayOutputStream(); + + while ((size = zip.read(buffer, 0, buffer.length)) != -1) { + bos.write(buffer, 0, size); + } + + bos.flush(); + bos.close(); + + append(connection, new FlatXmlDataSet(new StringReader(new String(bos.toByteArray()).trim()))); + } + } + } finally { + if (zip != null) { + zip.close(); + } + } + } + } + } finally { + tx.commit(); + } + } + } + + private void append(final Connection connection, final FlatXmlDataSet xmlDataSet) throws DatabaseUnitException, SQLException { + final DatabaseConnection databaseConnection = new DatabaseConnection(connection); + final ReplacementDataSet dataSet = new ReplacementDataSet(xmlDataSet); + dataSet.addReplacementObject("NULL", null); + + DatabaseOperation.CLEAN_INSERT.execute(databaseConnection, dataSet); + } +} diff --git a/ejb/src/test/resources/META-INF/ejb-jar.xml b/ejb/src/test/resources/META-INF/ejb-jar.xml new file mode 100644 index 0000000..446dae7 --- /dev/null +++ b/ejb/src/test/resources/META-INF/ejb-jar.xml @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/ejb/src/test/resources/fixtures/messages.xml b/ejb/src/test/resources/fixtures/messages.xml new file mode 100644 index 0000000..87b6fbd --- /dev/null +++ b/ejb/src/test/resources/fixtures/messages.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/jar/pom.xml b/jar/pom.xml new file mode 100644 index 0000000..a4554be --- /dev/null +++ b/jar/pom.xml @@ -0,0 +1,107 @@ + + + + 4.0.0 + + + be.dabla + tomee-maven-demo + 2.0.0 + + + tomee-maven-demo-jar + jar + tomee-maven-demo-jar + + + + commons-codec + commons-codec + 1.5 + + + javax.validation + validation-api + 1.0.0.GA + provided + + + javax.ejb + ejb-api + 3.0 + provided + + + junit + junit + 4.8.2 + test + + + org.hibernate + hibernate-validator + 4.0.2.GA + test + + + org.slf4j + slf4j-api + 1.6.1 + test + + + javaee + javaee-api + 5 + provided + + + + + + + org.apache.maven.plugins + maven-jar-plugin + + + + test-jar + + + + + + + + + + default + + true + + + + + src/main/resources + true + + + + + + tomcat + + + + src/main/resources + true + + **/persistence.xml + **/orm.xml + + + + + + + \ No newline at end of file diff --git a/jar/src/main/java/be/dabla/domain/EJBLocal.java b/jar/src/main/java/be/dabla/domain/EJBLocal.java new file mode 100644 index 0000000..0550eeb --- /dev/null +++ b/jar/src/main/java/be/dabla/domain/EJBLocal.java @@ -0,0 +1,11 @@ +package be.dabla.domain; + +import java.util.List; + +import javax.ejb.Local; + +@Local +public interface EJBLocal { + public Number count(); + public List findAll(int start, int size); +} \ No newline at end of file diff --git a/jar/src/main/java/be/dabla/domain/MessageEJBLocal.java b/jar/src/main/java/be/dabla/domain/MessageEJBLocal.java new file mode 100644 index 0000000..38e092c --- /dev/null +++ b/jar/src/main/java/be/dabla/domain/MessageEJBLocal.java @@ -0,0 +1,13 @@ +package be.dabla.domain; + +import javax.ejb.Local; + +import be.dabla.model.Message; + +@Local +public interface MessageEJBLocal extends EJBLocal { + public Message findById(final Long id); + public Message create(final Message entity); + public void delete(final Message Message); + public Message update(final Message entity); +} \ No newline at end of file diff --git a/jar/src/main/java/be/dabla/domain/MessageEJBRemote.java b/jar/src/main/java/be/dabla/domain/MessageEJBRemote.java new file mode 100644 index 0000000..1878aab --- /dev/null +++ b/jar/src/main/java/be/dabla/domain/MessageEJBRemote.java @@ -0,0 +1,8 @@ +package be.dabla.domain; + +import javax.ejb.Remote; + +@Remote +public interface MessageEJBRemote extends MessageEJBLocal { + +} \ No newline at end of file diff --git a/jar/src/main/java/be/dabla/domain/MessageMDBSenderLocal.java b/jar/src/main/java/be/dabla/domain/MessageMDBSenderLocal.java new file mode 100644 index 0000000..d151d28 --- /dev/null +++ b/jar/src/main/java/be/dabla/domain/MessageMDBSenderLocal.java @@ -0,0 +1,12 @@ +package be.dabla.domain; + +import javax.ejb.Local; +import javax.jms.JMSException; + +import be.dabla.model.Message; +import be.dabla.service.handler.Address; + +@Local +public interface MessageMDBSenderLocal { + public void sendMessage(final Address address) throws JMSException; +} \ No newline at end of file diff --git a/jar/src/main/java/be/dabla/domain/MessageMDBSenderRemote.java b/jar/src/main/java/be/dabla/domain/MessageMDBSenderRemote.java new file mode 100644 index 0000000..10fd2c3 --- /dev/null +++ b/jar/src/main/java/be/dabla/domain/MessageMDBSenderRemote.java @@ -0,0 +1,8 @@ +package be.dabla.domain; + +import javax.ejb.Remote; + +@Remote +public interface MessageMDBSenderRemote extends MessageMDBSenderLocal { + +} \ No newline at end of file diff --git a/jar/src/main/java/be/dabla/model/Message.java b/jar/src/main/java/be/dabla/model/Message.java new file mode 100644 index 0000000..d27c4a1 --- /dev/null +++ b/jar/src/main/java/be/dabla/model/Message.java @@ -0,0 +1,89 @@ +package be.dabla.model; + +import java.io.Serializable; +import java.util.Date; + +import javax.xml.bind.annotation.XmlAccessType; +import javax.xml.bind.annotation.XmlAccessorType; +import javax.xml.bind.annotation.XmlElement; + +@XmlAccessorType(XmlAccessType.NONE) +public class Message implements Serializable { + @XmlElement + private Long id; + @XmlElement(required = true) + private String description; + @XmlElement + private Date date; + + public Message() { + this(null); + } + + public Message(final String description) { + this.description = description; + this.date = new Date(); + } + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public Date getDate() { + return date; + } + + public void setDate(Date date) { + this.date = date; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((date == null) ? 0 : date.hashCode()); + result = prime * result + + ((description == null) ? 0 : description.hashCode()); + result = prime * result + ((id == null) ? 0 : id.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + Message other = (Message) obj; + if (date == null) { + if (other.date != null) + return false; + } else if (!date.equals(other.date)) + return false; + if (description == null) { + if (other.description != null) + return false; + } else if (!description.equals(other.description)) + return false; + if (id == null) { + if (other.id != null) + return false; + } else if (!id.equals(other.id)) + return false; + return true; + } +} \ No newline at end of file diff --git a/jar/src/main/java/be/dabla/model/validation/EntityTraversableResolver.java b/jar/src/main/java/be/dabla/model/validation/EntityTraversableResolver.java new file mode 100644 index 0000000..ab0f593 --- /dev/null +++ b/jar/src/main/java/be/dabla/model/validation/EntityTraversableResolver.java @@ -0,0 +1,16 @@ +package be.dabla.model.validation; + +import java.lang.annotation.ElementType; + +import javax.validation.Path; +import javax.validation.TraversableResolver; + +public class EntityTraversableResolver implements TraversableResolver { + public boolean isReachable(final Object traversableObject, final Path.Node traversableProperty, final Class rootBeanType, final Path pathToTraversableObject, final ElementType elementType) { + return (traversableObject != null); + } + + public boolean isCascadable(final Object traversableObject, final Path.Node traversableProperty, final Class rootBeanType, final Path pathToTraversableObject, final ElementType elementType) { + return true; + } +} \ No newline at end of file diff --git a/jar/src/main/java/be/dabla/model/validation/EntityValidationEventListener.java b/jar/src/main/java/be/dabla/model/validation/EntityValidationEventListener.java new file mode 100644 index 0000000..11ecdd0 --- /dev/null +++ b/jar/src/main/java/be/dabla/model/validation/EntityValidationEventListener.java @@ -0,0 +1,37 @@ +package be.dabla.model.validation; + +import java.util.HashSet; +import java.util.Set; + +import javax.validation.ConstraintViolation; +import javax.validation.ConstraintViolationException; +import javax.validation.TraversableResolver; +import javax.validation.Validation; +import javax.validation.Validator; + +// http://agoncal.wordpress.com/2010/03/03/bean-validation-with-jpa-1-0/ +public class EntityValidationEventListener { + private final TraversableResolver resolver; + private final Validator validator; + + public EntityValidationEventListener() { + resolver = new EntityTraversableResolver(); + validator = Validation.buildDefaultValidatorFactory().usingContext().traversableResolver(resolver).getValidator(); + } + + public void validate(final Object entity) { + final Set> constraintViolations = validator.validate(entity); + + if (!constraintViolations.isEmpty()) { + final Set> propagatedViolations = new HashSet>(constraintViolations.size()); + final Set classNames = new HashSet(); + + for (final ConstraintViolation violation : constraintViolations) { + propagatedViolations.add(violation); + classNames.add(violation.getLeafBean().getClass().getName()); + } + + throw new ConstraintViolationException(new StringBuilder().append("validation failed for classes ").append(classNames).toString(), propagatedViolations); + } + } +} diff --git a/jar/src/main/java/be/dabla/service/MessageService.java b/jar/src/main/java/be/dabla/service/MessageService.java new file mode 100644 index 0000000..61c6173 --- /dev/null +++ b/jar/src/main/java/be/dabla/service/MessageService.java @@ -0,0 +1,21 @@ +package be.dabla.service; + +import javax.jws.Oneway; +import javax.jws.WebMethod; +import javax.jws.WebParam; +import javax.jws.WebService; +import javax.xml.ws.soap.Addressing; + +import be.dabla.model.Message; + +@Addressing +@WebService(targetNamespace = "urn:service.dabla.be") +public interface MessageService { + @WebMethod(action = "create") + @Oneway + public void create(@WebParam(partName = "payload", name = "Message", targetNamespace = "urn:model.dabla.be")final Message payload); + + @WebMethod(action = "callbackMessage") + @Oneway + public void callbackMessage(@WebParam(partName = "payload", name = "Message", targetNamespace = "urn:model.dabla.be")final Message payload); +} \ No newline at end of file diff --git a/jar/src/main/java/be/dabla/service/MessageServiceClient.java b/jar/src/main/java/be/dabla/service/MessageServiceClient.java new file mode 100644 index 0000000..b97a492 --- /dev/null +++ b/jar/src/main/java/be/dabla/service/MessageServiceClient.java @@ -0,0 +1,50 @@ +package be.dabla.service; + +import java.net.URL; + +import javax.xml.namespace.QName; +import javax.xml.ws.Service; +import javax.xml.ws.WebEndpoint; +import javax.xml.ws.WebServiceClient; +import javax.xml.ws.WebServiceFeature; + +@WebServiceClient(name = "MessageService", targetNamespace = "urn:service.dabla.be", wsdlLocation="file:/tomee-maven-demo/war/src/main/resources/wsdl/MessageService.wsdl") +public class MessageServiceClient extends Service { + public final static URL WSDL_LOCATION = Thread.currentThread().getContextClassLoader().getResource("wsdl/MessageService.wsdl"); + public final static QName SERVICE = new QName("urn:service.dabla.be", "MessageService"); + public final static QName PORT = new QName("urn:service.dabla.be", "MessageServicePort"); + + public MessageServiceClient(URL wsdlLocation) { + super(WSDL_LOCATION, SERVICE); + } + + public MessageServiceClient(URL wsdlLocation, QName serviceName) { + super(WSDL_LOCATION, serviceName); + } + + public MessageServiceClient() { + super(WSDL_LOCATION, SERVICE); + } + + /** + * + * @return + * returns MessageService + */ + @WebEndpoint + public MessageService getMessageService() { + return super.getPort(PORT, MessageService.class); + } + + /** + * + * @param features + * A list of {@link javax.xml.ws.WebServiceFeature} to configure on the proxy. Supported features not in the features parameter will have their default values. + * @return + * returns MessageService + */ + @WebEndpoint + public MessageService getMessageService(WebServiceFeature... features) { + return super.getPort(PORT, MessageService.class, features); + } +} \ No newline at end of file diff --git a/jar/src/main/java/be/dabla/service/handler/Address.java b/jar/src/main/java/be/dabla/service/handler/Address.java new file mode 100644 index 0000000..e2e27f2 --- /dev/null +++ b/jar/src/main/java/be/dabla/service/handler/Address.java @@ -0,0 +1,115 @@ +package be.dabla.service.handler; + +import java.io.Serializable; +import java.util.Map; + +public final class Address implements Serializable { + T content; + String messageId; + String to; + String replyTo; + Map parameters; + + public Address(final T content, final String messageId, final String to, final String replyTo) { + this(content, messageId, to, replyTo, null); + } + + public Address(final T content, final String messageId, final String to, final String replyTo, final Map parameters) { + setContent(content); + setMessageId(messageId); + setTo(to); + setReplyTo(replyTo); + setParameters(parameters); + } + + public T getContent() { + return content; + } + + public void setContent(T content) { + this.content = content; + } + + public String getMessageId() { + return messageId; + } + + public void setMessageId(String messageId) { + this.messageId = messageId; + } + + public String getTo() { + return to; + } + + public void setTo(String to) { + this.to = to; + } + + public String getReplyTo() { + return replyTo; + } + + public void setReplyTo(String replyTo) { + this.replyTo = replyTo; + } + + public Map getParameters() { + return parameters; + } + + public void setParameters(Map parameters) { + this.parameters = parameters; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((content == null) ? 0 : content.hashCode()); + result = prime * result + + ((messageId == null) ? 0 : messageId.hashCode()); + result = prime * result + + ((parameters == null) ? 0 : parameters.hashCode()); + result = prime * result + ((replyTo == null) ? 0 : replyTo.hashCode()); + result = prime * result + ((to == null) ? 0 : to.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + Address other = (Address) obj; + if (content == null) { + if (other.content != null) + return false; + } else if (!content.equals(other.content)) + return false; + if (messageId == null) { + if (other.messageId != null) + return false; + } else if (!messageId.equals(other.messageId)) + return false; + if (parameters == null) { + if (other.parameters != null) + return false; + } else if (!parameters.equals(other.parameters)) + return false; + if (replyTo == null) { + if (other.replyTo != null) + return false; + } else if (!replyTo.equals(other.replyTo)) + return false; + if (to == null) { + if (other.to != null) + return false; + } else if (!to.equals(other.to)) + return false; + return true; + } +} \ No newline at end of file diff --git a/jar/src/main/java/be/dabla/service/handler/WSAddressingClientHandler.java b/jar/src/main/java/be/dabla/service/handler/WSAddressingClientHandler.java new file mode 100644 index 0000000..2fdf44a --- /dev/null +++ b/jar/src/main/java/be/dabla/service/handler/WSAddressingClientHandler.java @@ -0,0 +1,76 @@ +package be.dabla.service.handler; + +import java.util.Iterator; +import java.util.Map; +import java.util.Set; +import java.util.logging.Level; +import java.util.logging.Logger; + +import javax.xml.namespace.QName; +import javax.xml.soap.SOAPHeader; +import javax.xml.soap.SOAPHeaderElement; +import javax.xml.ws.handler.MessageContext; +import javax.xml.ws.handler.soap.SOAPHandler; +import javax.xml.ws.handler.soap.SOAPMessageContext; + +public class WSAddressingClientHandler implements SOAPHandler { + static final Logger logger = Logger.getLogger(WSAddressingClientHandler.class.getName()); + Address address = null; + + public Address getAddress() { + return address; + } + + public void setAddress(final Address address) { + this.address = address; + } + + public Set getHeaders() { + return null; + } + + public boolean handleMessage(final SOAPMessageContext context) { + final Boolean outboundProperty = (Boolean)context.get(MessageContext.MESSAGE_OUTBOUND_PROPERTY); + + logger.log(Level.FINE, "outboundProperty: {0}", outboundProperty); + + if (outboundProperty.booleanValue() && (getAddress() != null)) { + try { + SOAPHeader header = context.getMessage().getSOAPHeader(); + + if(header == null) { + header = context.getMessage().getSOAPPart().getEnvelope().addHeader(); + } + + header.addHeaderElement(new QName("http://www.w3.org/2005/08/addressing","RelatesTo")).addTextNode(address.getMessageId()); + + logger.log(Level.FINE, "parameters: {0}", getAddress().getParameters()); + + if (getAddress().getParameters() != null) { + final SOAPHeaderElement element = header.addHeaderElement(new QName("http://www.w3.org/2005/08/addressing","ReferenceParameters")); + final Iterator> i = getAddress().getParameters().entrySet().iterator(); + + while(i.hasNext()) { + final Map.Entry entry = i.next(); + + logger.log(Level.FINE, "entry: {0}", entry); + + element.addChildElement(new QName("http://xmlns.oracle.com/sca/tracking/1.0",entry.getKey())).addTextNode(entry.getValue()); + } + } + } catch (Exception e) { + logger.warning(e.getMessage()); + } + } + + return true; + } + + public boolean handleFault(final SOAPMessageContext smc) { + return true; + } + + public void close(final MessageContext messageContext) { + setAddress(null); + } +} \ No newline at end of file diff --git a/jar/src/main/resources/META-INF/orm.xml b/jar/src/main/resources/META-INF/orm.xml new file mode 100644 index 0000000..dc6e18d --- /dev/null +++ b/jar/src/main/resources/META-INF/orm.xml @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + TIMESTAMP + + + + \ No newline at end of file diff --git a/jar/src/main/resources/META-INF/persistence.xml b/jar/src/main/resources/META-INF/persistence.xml new file mode 100644 index 0000000..be6b63f --- /dev/null +++ b/jar/src/main/resources/META-INF/persistence.xml @@ -0,0 +1,14 @@ + + + + org.eclipse.persistence.jpa.PersistenceProvider + jdbc/tomee-maven-demo-ds + + + + + + + + \ No newline at end of file diff --git a/jar/src/test/java/be/dabla/model/MessageTest.java b/jar/src/test/java/be/dabla/model/MessageTest.java new file mode 100644 index 0000000..1ec5dfa --- /dev/null +++ b/jar/src/test/java/be/dabla/model/MessageTest.java @@ -0,0 +1,24 @@ +package be.dabla.model; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import be.dabla.model.Message; + +public class MessageTest { + @Test + public void testEquals() throws Exception { + final Message request = new Message(); + + request.hashCode(); + assertFalse(request.equals(null)); + assertTrue(request.equals(request)); + assertTrue(request.equals(new Message())); + + request.setDescription(""); + assertNotNull(request.getDescription()); + } +} \ No newline at end of file diff --git a/jar/src/test/java/be/dabla/service/MockMessageContext.java b/jar/src/test/java/be/dabla/service/MockMessageContext.java new file mode 100644 index 0000000..2b1da17 --- /dev/null +++ b/jar/src/test/java/be/dabla/service/MockMessageContext.java @@ -0,0 +1,91 @@ +package be.dabla.service; + +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; +import java.util.UUID; + +import javax.xml.ws.handler.MessageContext; + +public class MockMessageContext implements MessageContext { + private Map map; + + public MockMessageContext() { + map = new HashMap(); + map.put("com.sun.xml.ws.api.addressing.messageId", "uuid:" + UUID.randomUUID()); + map.put("com.sun.xml.ws.api.addressing.to", "http://localhost:7001/bc-core-utils-bc1-sync-context-root/UserService"); + map.put("com.sun.xml.ws.addressing.WsaPropertyBag.ReplyToFromRequest", "http://localhost:9999/UserMockService"); + } + + @Override + public Scope getScope(String name) { + // TODO Auto-generated method stub + return null; + } + + @Override + public void setScope(String name, Scope scope) { + // TODO Auto-generated method stub + } + + @Override + public void clear() { + map.clear(); + } + + @Override + public boolean containsKey(Object key) { + return map.containsKey(key); + } + + @Override + public boolean containsValue(Object value) { + return map.containsValue(value); + } + + @Override + public Set> entrySet() { + return map.entrySet(); + } + + @Override + public Object get(Object key) { + return map.get(key); + } + + @Override + public boolean isEmpty() { + return map.isEmpty(); + } + + @Override + public Set keySet() { + return map.keySet(); + } + + @Override + public Object put(String key, Object value) { + return map.put(key, value); + } + + @Override + public void putAll(Map m) { + map.putAll(m); + } + + @Override + public Object remove(Object key) { + return map.remove(key); + } + + @Override + public int size() { + return map.size(); + } + + @Override + public Collection values() { + return map.values(); + } +} \ No newline at end of file diff --git a/jar/src/test/java/be/dabla/service/MockSOAPMessageContext.java b/jar/src/test/java/be/dabla/service/MockSOAPMessageContext.java new file mode 100644 index 0000000..4757390 --- /dev/null +++ b/jar/src/test/java/be/dabla/service/MockSOAPMessageContext.java @@ -0,0 +1,43 @@ +package be.dabla.service; + +import java.util.Set; + +import javax.xml.bind.JAXBContext; +import javax.xml.namespace.QName; +import javax.xml.soap.MessageFactory; +import javax.xml.soap.SOAPException; +import javax.xml.soap.SOAPMessage; +import javax.xml.ws.handler.MessageContext; +import javax.xml.ws.handler.soap.SOAPMessageContext; + + +public class MockSOAPMessageContext extends MockMessageContext implements SOAPMessageContext { + SOAPMessage message = null; + + public MockSOAPMessageContext() throws SOAPException { + super(); + + put(MessageContext.MESSAGE_OUTBOUND_PROPERTY, Boolean.valueOf(false)); + setMessage(MessageFactory.newInstance().createMessage()); + } + + @Override + public Object[] getHeaders(QName header, JAXBContext context, boolean allRoles) { + return null; + } + + @Override + public SOAPMessage getMessage() { + return message; + } + + @Override + public Set getRoles() { + return null; + } + + @Override + public void setMessage(SOAPMessage message) { + this.message = message; + } +} \ No newline at end of file diff --git a/jar/src/test/java/be/dabla/service/handler/AddressTest.java b/jar/src/test/java/be/dabla/service/handler/AddressTest.java new file mode 100644 index 0000000..3b4b34b --- /dev/null +++ b/jar/src/test/java/be/dabla/service/handler/AddressTest.java @@ -0,0 +1,29 @@ +package be.dabla.service.handler; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import be.dabla.model.Message; +import be.dabla.service.handler.Address; + +public class AddressTest { + @Test + public void testAddress() { + final Address address = MockAddress.mock(); + assertEquals(address.getContent(), MockAddress.MESSAGE); + assertEquals(address.getMessageId(), MockAddress.MESSAGE_ID); + assertEquals(address.getTo(), MockAddress.ADDRESS); + assertEquals(address.getReplyTo(), MockAddress.ADDRESS); + + assertFalse(address.equals(null)); + assertFalse(address.equals(new Address(null, null, null, null))); + assertFalse(address.equals(new Address(MockAddress.MESSAGE, "", "", ""))); + assertTrue(address.equals(address)); + assertTrue(address.equals(MockAddress.mock())); + + address.hashCode(); + } +} \ No newline at end of file diff --git a/jar/src/test/java/be/dabla/service/handler/MockAddress.java b/jar/src/test/java/be/dabla/service/handler/MockAddress.java new file mode 100644 index 0000000..6af9607 --- /dev/null +++ b/jar/src/test/java/be/dabla/service/handler/MockAddress.java @@ -0,0 +1,14 @@ +package be.dabla.service.handler; + +import be.dabla.model.Message; +import be.dabla.service.handler.Address; + +public class MockAddress { + public static final Message MESSAGE = new Message("Hello World"); + public static final String MESSAGE_ID = "uuid:cc633354-97d1-4940-a2a3-9b6d18b1fe81"; + public static final String ADDRESS = "http://www.w3.org/2005/08/addressing/anonymous"; + + public static Address mock() { + return new Address(MESSAGE, MESSAGE_ID, ADDRESS, ADDRESS); + } +} \ No newline at end of file diff --git a/jar/src/test/java/be/dabla/service/handler/WSAddressingClientHandlerTest.java b/jar/src/test/java/be/dabla/service/handler/WSAddressingClientHandlerTest.java new file mode 100644 index 0000000..a1f2ec9 --- /dev/null +++ b/jar/src/test/java/be/dabla/service/handler/WSAddressingClientHandlerTest.java @@ -0,0 +1,35 @@ +package be.dabla.service.handler; + +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import javax.xml.soap.SOAPException; +import javax.xml.ws.handler.MessageContext; +import javax.xml.ws.handler.soap.SOAPMessageContext; + +import org.junit.Test; + +import be.dabla.service.MockSOAPMessageContext; +import be.dabla.service.handler.WSAddressingClientHandler; + +public class WSAddressingClientHandlerTest { + @Test + public void testHandler() throws SOAPException { + final WSAddressingClientHandler handler = new WSAddressingClientHandler(); + assertNull(handler.getHeaders()); + assertNull(handler.getAddress()); + + final SOAPMessageContext context = new MockSOAPMessageContext(); + handler.handleMessage(context); + context.put(MessageContext.MESSAGE_OUTBOUND_PROPERTY, Boolean.valueOf(true)); + handler.handleMessage(context); + handler.setAddress(MockAddress.mock()); + assertNotNull(handler.getAddress()); + handler.handleMessage(context); + context.getMessage().getSOAPPart().getEnvelope().removeChild(context.getMessage().getSOAPHeader()); + handler.handleMessage(context); + + handler.handleFault(context); + handler.close(context); + } +} \ No newline at end of file diff --git a/jar/src/test/resources/jndi.properties b/jar/src/test/resources/jndi.properties new file mode 100644 index 0000000..7e90c95 --- /dev/null +++ b/jar/src/test/resources/jndi.properties @@ -0,0 +1,20 @@ +java.naming.factory.initial=org.apache.openejb.client.LocalInitialContextFactory +openejb.embedded.remotable=true +# following line ignores the weblogic-ejb-jar.xml +openejb.vendor.config=NONE +# http://openejb.apache.org/3.0/configuring-persistenceunits-in-tests.html +jdbc/tomee-maven-demo-ds=new://Resource?type=DataSource +jdbc/tomee-maven-demo-ds.JdbcDriver=org.apache.derby.jdbc.EmbeddedDriver +jdbc/tomee-maven-demo-ds.JdbcUrl=jdbc:derby:derby;create=true +jdbc/tomee-maven-demo-ds.Username=APP +jdbc/tomee-maven-demo-ds.Password=APP +tomee-maven-demo-pu.eclipselink.logging.level=SEVERE +tomee-maven-demo-pu.eclipselink.ddl-generation=drop-and-create-tables +tomee-maven-demo-pu.eclipselink.target-database=org.eclipse.persistence.platform.database.DerbyPlatform + +Default\ JMS\ Resource\ Adapter=new://Resource?type=ActiveMQResourceAdapter +Default\ JMS\ Resource\ Adapter.ServerUrl=tcp://localhost:61616 +Default\ JMS\ Resource\ Adapter.BrokerXmlConfig=broker:(tcp://localhost:61616) +jms/tomee-maven-demo-cf=new://Resource?type=javax.jms.ConnectionFactory +jms/tomee-maven-demo-cf.ResourceAdapter=Default JMS Resource Adapter +jms/tomee-maven-demo-q=new://Resource?type=javax.jms.Queue \ No newline at end of file diff --git a/jar/src/test/resources/logging.properties b/jar/src/test/resources/logging.properties new file mode 100644 index 0000000..d4a07c1 --- /dev/null +++ b/jar/src/test/resources/logging.properties @@ -0,0 +1,34 @@ +# Add handlers to the root logger. +# These are inherited by all other loggers. +handlers=java.util.logging.ConsoleHandler, java.util.logging.FileHandler + +# Configure the ConsoleHandler. +# ConsoleHandler uses java.util.logging.SimpleFormatter by default. +# Even though the root logger has the same level as this, +# the next line is still needed because we're configuring a handler, +# not a logger, and handlers don't inherit properties from the root logger. +java.util.logging.ConsoleHandler.level=FINE + +# Configure the FileHandler. +# FileHandler uses java.util.logging.XMLFormatter by default. +java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter +java.util.logging.FileHandler.level=FINEST + +# The following special tokens can be used in the pattern property +# which specifies the location and name of the log file. +# / - standard path separator +# %t - system temporary directory +# %h - value of the user.home system property +# %g - generation number for rotating logs +# %u - unique number to avoid conflicts +# FileHandler writes to %h/demo0.log by default. +java.util.logging.FileHandler.pattern=target/test.log + +# Set the logging level of the root logger. +# Levels from lowest to highest are +# FINEST, FINER, FINE, CONFIG, INFO, WARNING and SEVERE. +# The default level for all loggers and handlers is INFO. +.level=INFO + +# Specify logging levels for specific namespaces. +be.dabla=FINEST \ No newline at end of file diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..08334f2 --- /dev/null +++ b/pom.xml @@ -0,0 +1,135 @@ + + + + 4.0.0 + + be.dabla + tomee-maven-demo + 2.0.0 + pom + TomEE Maven Demo + + + dablomatique + http://dablomatique.wordpress.com/ + + + + + dabla + David Blain + + developer + + dablomatique@gmail.com + dablomatique + + + + + jar + ejb + war + ear + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 2.0.2 + + 1.6 + 1.6 + + + + org.apache.maven.plugins + maven-surefire-plugin + 2.9 + + once + + + + java.util.logging.config.file + ${build.testOutputDirectory}/logging.properties + + + + + + org.codehaus.mojo + cobertura-maven-plugin + 2.5.1 + + + + + + org.codehaus.mojo + cobertura-maven-plugin + + + + + **/jaxws/*.class + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + + + + + + + org.apache.maven.plugins + maven-project-info-reports-plugin + 2.1.2 + + + + index + summary + project-team + dependencies + dependency-convergence + + + + + + org.apache.maven.plugins + maven-checkstyle-plugin + 2.1 + + + org.codehaus.mojo + cobertura-maven-plugin + 2.5.1 + + + + + + + dev + + true + + + Development + jdbc:oracle:thin:@localhost:1521:XE + scott + scott + + + + \ No newline at end of file diff --git a/war/derby/db.lck b/war/derby/db.lck new file mode 100644 index 0000000000000000000000000000000000000000..f36162acad85e86063fc04496a74f930fa83e822 GIT binary patch literal 38 qcmZQjNwhFDOExe_)ip3QHq|vYF*MUPH?~aEO#=agL=!`kR7(J;?FnZ9 literal 0 HcmV?d00001 diff --git a/war/derby/log/log.ctrl b/war/derby/log/log.ctrl new file mode 100644 index 0000000000000000000000000000000000000000..da8655bc46482e276a10592d958a1f7cb13429eb GIT binary patch literal 48 mcmZQzU}#`qVBiE|Mg}H}Fd)qZ#4HS4%`1R33NV~6Sq=b6(gVH# literal 0 HcmV?d00001 diff --git a/war/derby/log/log1.dat b/war/derby/log/log1.dat new file mode 100644 index 0000000000000000000000000000000000000000..98a342f2ef7df84ab14f2e1b2c0a8640f6ff2930 GIT binary patch literal 157577 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

=b!;!uuK$;vtZPge|gy9g!jr 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 literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c101.dat b/war/derby/seg0/c101.dat new file mode 100644 index 0000000000000000000000000000000000000000..91746f76f62616de32bf0e3c7875f4a2ac28aa8d GIT binary patch literal 8192 zcmeI1zfQw25XSF{)TaL=9s;nYr=NIU{U%xq0*24+BFV_`%>3@ogOiHRrRDf$eI ztW0pZ)K%0Jy2EG5XW#j=FaB-5&?OPE^s=?ow$;{+U$4hx{&Svi*;5N&%A zOLFmlZPjP3NIqX)pQ=#pEDh|v%fP0VWMymVYR=$#%?d&w00JNY0w4eaAOHd&00JNY z0wD0W2;4qiFZTQ(~Km89K~lEDoH%R<1~+44C5&S%=^c@<@!x_sl8 zwSXf!S?E7BB1MTeS?RQBmv&BV8ab0qLKE3Iw04|^ac1+dD4UtM$jvg^5;X^^ALWzr z)MWW4eZXDSC#lV*CQ7_Mm7O*(8s~Spr}~+(g)`B3lfK7&)jMNdYNFWdizH05(X4TP zp9bsnvOUb>)8>5#3uG8T00ck)1V8`;KmY_l00ck)1pWyDPDuWH({pLLt@c4}q4Bxe M13Ig4+_}U1Z~drjFaQ7m literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c111.dat b/war/derby/seg0/c111.dat new file mode 100644 index 0000000000000000000000000000000000000000..5ce79a2e2e2395437695f9295505073c91d31e26 GIT binary patch literal 8192 zcmeI0y-EZz5XUFCu)FsKem#O{wUBIba)Py$h$1$2>m61i2r6i0W9bvvT3A^51U`VZ z^_5m)Yo)Wv?y=-nVGA4i4`h;=WdE7`wo2%Nhy=IXTGofwS6w+@&GGoFFfaXMxWhAN z++w1+a*^Q8IsVmLS>BS*$ESOjs%Y87>Kk`LRyOfI%|p9qd|fkx6bOI-2!H?xfB*=9 z00@8p2!H?x{4WBxcb9_B`Ap^gzE2TH{h3qFz6iJ_VZ=`cHxy4F0%}K7x$>SbNQqaM z74yYxzjdSKQX)zYP& zufhtXaIorR@4qXwE;BK4etnX~o)cIzN=U-K8g@1HUICH^0Alj}) zf){81*H&(;CHZ`LeJVqZS}w5v&Vx{mMOvR)*R2`c^kfhM0T2KI5C8!X009sH0T2KI z5CDO{Md0r7TF@n*slMM&X~5pJbIR_EKq>JD{A6%T!TKSfceXB9-}40>h*cRCJ5|=+ z@jc$iF`ZVC4<7Btyf+>P9_`WYLhD4S)JPTTL~1=ZGD&qV3)@r{hw(C{Emn(QBYhx- zPM?^lFe;4e`X-l3=S8RfP>eRxkHpyNGZkeE-g{lYm`RgH%TE0HnnLNwGu`hL!mQ7(5hup(E%!GRTpT}wnaDSGG3xv)bnFf zOgljQM;x8^p7ZdxQ#ufl#%DYl$*d=HaZ>qWjPGCBD1~d6GtTVNY+DtX+}u!$nrmhI z?c>@j?UmJyo*dT%(WgnpzDZBxT#-Qt0uX=z1Rwwb2tWV=5P$##An;!Tm)lXJJ-?Is z!0se}09s#fsq&>nQ|BkUT9k+5uWsIB$_JSZ8qz=tSNg*CEMdEz+%JB^oY(sOjt^E~o*Cj)sz!hBl%?6r2Dqkuy-y zQ^D*wj;uJ49{!bfc6a9A*VoO^6%ny?*IH`ZYU`$o*L^boTDCR!kIPeuTuAqbb}JFf z<+A>@mCss}d_KL*OIPhIbsW6Qz@~P|+E%yJJH49?5x77A1V8`;KmY_l00ck)1V8`; zK;Ul?xO=!}x|Bav`TdYOvKlsi*{leZl6FT*2Djv`3IQ8utK+IXpXrbnrI(MFQJ3Sp zTEGdNEhCb^>%&^FGImO*70!~{{LFJeDQN3+KH zeHv`i%XUAHrp^BjN@TDg00JNY0w4eaAOHd&00JNY0{?{o$K=xHM`yXM_FiqF{)O5j MIxl%VzkSTV0b`qO5C8xG literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c150.dat b/war/derby/seg0/c150.dat new file mode 100644 index 0000000000000000000000000000000000000000..93248fd5ad0dd41da449402416312b811a5dee8e GIT binary patch literal 8192 zcmeHMO=uHA6n?WNX__Wlty;DIHI1#8h1uQw?1HBrauKBmZ&hf1X+dj|rc^3e5D`JK z7f)X7#Z&KIy?Pcsc#>WeR1kXcAn3f;q?VfQgomL}W|sZ3^JezjZ@+yrJ4s*x0EF7H zScEac?a*r99#hA^n`K9M*Xo37ncr;fZ*@wli^p4)T|S4~#fzzz>znZ{uBObfFDfo1 zz*a+>^XZ!LNo;dMS^zdiNGjivQEzTrI)j%qrmeDzMTuavR%g_ zOIasd3)F89>)6+qSRCJ$vMTL*wNS9VS{19Zq_(mXNC|oISOn@yLT$;)?VF8Tv*R=K zS4wkWt$l}R;|^Gp<7*p(KV$K0pVW^Ui*wl7hd5J?>vloT6!bFXIHgcI7CeFkliCe8 z9;y4d)OoGyB$rxmNQ$WQPR-9suikkkcInX{WXkEvz?g;FrJTcsioHIV_fP$OMRTE-Jt4Mq^GiQPv0!lFvyhC zrRn7aSB{z)|NDD)5l%AYc;R`#TLw(QDW)7JJmYz@U3wXYxO%!V`>LhVX|5jq6nTb8 z-ND3umPw84(vY0Tcg8s`by-V&o=NS5FG*4LFq7I1PjjSBbE);q%MmWMKKU|CYEQp% zy}+feXftG#N$nQ2)MH%g@Oc?CWIvYFFPH>Ktr8XylV1r}2y=*i9|`XhW)Kr^31_zC2~r|J<Y&{;Nh+FWGEfz{)=m({|U(g7G^)O$m1c&*W8U8`B zP^?xEgNnmp`40M6ejoZ-em@3S{s0D9{vd|PFBhs|(GP0BG9&>> zKoXDyBmqf468M7zVq4JvD#u(y>xFnvydv%rJww$bJ`rz-HDZ})8=^tHGqhW*)A<(B rHSB#M-V?8gyF|~hr%8Mw-VkfVGSN1SHHde_x*;}j(h8&bu<5=7A$)^V literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c171.dat b/war/derby/seg0/c171.dat new file mode 100644 index 0000000000000000000000000000000000000000..33afae61f928b75c13512d7dfb6682147656fa82 GIT binary patch literal 8192 zcmeI1yKWOf6o&uVn>SZGH|Kt{oi&ZcdJT3WQKyWkQcxfzI4PO+nt$zXV=;>`T&gGsCZ5zr(E(pkJ6$|XkBz^ zH$AhT^X5^S!iOm!W_*@Oe2gi^H_s$~3e$|w#QscUhVyOd{4<#4yx5;v%yC{E?;PeC zFZ(%GJ%ky~^Yn<;%{aM30<6C0?*RjF)rs&TGHaRcOpG|CWUYrkG*k-&u-?p*C_||jD zpB?OS{#@dBvB&tPct7r8pYfUK=RPW&7oR^BR5>sDSw)TUE%A9(!vW{tNd6okVSLt+ z_yl#%i}SN?e=)SE1L}Y}pbn@5>VP`%4;+Y&VgFSQ6Vf0ejmoZmPwEdz!*8VC4XL>$ zjRvItF==>5>N&==UA9kZdZfV@mpvu*2QKa+7*ajFaq%)~&?EH{SHE@jJ5m#o`h8cw WC&hp?JS7d1y8 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 literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c191.dat b/war/derby/seg0/c191.dat new file mode 100644 index 0000000000000000000000000000000000000000..8c72abfc0e9eb96c5b713f40fe45195fddb2bd09 GIT binary patch literal 16384 zcmeI2ON`q@7{|Xj59hJj-EN<|eNalFTvkfEeWaz7IL;(>*NI)*X}f*k($@h_NVEcR zfvTV$;RND_5J=qM036}M1tEbrR0yG-5kiRG5JH0Q8z;_d+)lU^jir2XJoay9zWHYC z@9)4307&77whXs9Zih|3eE1md|I^#X4k!L}vE(KEUp`il$zkfQ!JCkel>p&h@3KLnpMsUto#<%l?OrKq z4{2;k2fFw<+beyIA4O&258Uae>lz%)!V|Fja%JyIwNkmVT&Y~Uw7l=&{=>_aLsu{3 zPuljb?7y~Bf%UM?U-L~rtat6z(CYZi3#cL&O{N$#(@}-WDi0_RC=VzPC=VzPC=VzP zC=VzPC=VzPC=WdR9{3Cb?8H%cCF)9WXU|_F`TtpX5=&YW9ZkspA*W;d|Hg3o-@7y& z=hcIxe~`apmak{V6Zq=#flCKgmiJYk!z?~Z;16HDQmq2!=xr7l4I?o6dAnAEygXnQ zX8e=3X|$Q|8!gs{q;x3ALl$73Adc;N)+x(oE#}9dSt!bbW}p~>y6w&YQHGK{VjgA@ z(R4g!wK}V8Eyid%%*bO%89_|9V+NMfaShLC$E2(dWqDHM;XY{q$-%5VB!m2OXwxP@JBJB>k2I&71#=?GM(t|{y|rwwZ$=9Xc*e1$t;o4CR;=nNd1 zfF|CmaF&|3Q#U)H8G}gd8o>haDEZVV>ZLl8$yw6oh!g$dDK=|Bor>J zuH##@)Hgk+?FXLKX;G~6#ued+JaHQ=35Y|DWMKm54D;+ z3WJJJ2|=|EYKA;(3APYxEUM~jLG)Zi5uoRwR+lGYR0)VjRSm}AF zHRLfkkUh+32MbVRQ&TXgVhV+WUW8h6YRY&}>7|LMc6C5`KzTsY1G#VUy))#_!HWRd zd+S#-_im$D|h9=rq;RMHJ_$w7eCBaxuDXuZ2__zpwON5GkVvGojQ_cS z6GNU4(QTe?e`!n!DL@XtJ zytnL(>v%zUvdg?R>Mpe~BT@_!QM+N+BnoqhI`-QM*_oh;8cQFYEeLdkMD%zo<3ZuA z%n7uFMAUdIIV!Q0d4ax=h>jDrrpMS>HW`O=0+At+wjH)c?!@P@7!{)E;Nrhs_z>}k zED0nBIVL{B1{MlvBeDT!mIdNNA~WtawX=(V#R(15#9*h9CR#2h5Frw2@$9qOJRXN7 z!i-3RNF+TDk463)B1Pj&xza>Diqwfjb{vmA_GmojlY|OUc8~vg8foTGJPO-cOj0mJ z@Hiv3I*|xr3Rfb$zi+Bc6-^XSU(XwUOA%E9dgw0Vvbx{-$ zuS4_jh&(UuF>AXx$kb=nW_X)54ZK6rET=Z&YXh|@4=4{P4=4{P5BzUEp#K0a=Iysg zN6;&jljnZs_BOXGq&Q^na{D@5!2N@i?Pq?1^Jw3qTs>2#Ytz5e`RVt#wdsg<56+?e ph|bqm`95%^U>BW}`WQ~5Jr8ZP3q0rlinIXK7e?~`@;9xU{{kk~Y=8g& literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c1a1.dat b/war/derby/seg0/c1a1.dat new file mode 100644 index 0000000000000000000000000000000000000000..fbd454fb57b7f16240b3bdb54469a82f26fbc82d GIT binary patch literal 8192 zcmeI1OK;>v5XZ~oar-rs2af>D8fqek*@a2vfSwZ%q zIgelT;rQ>f<01Ede*6q0-{LC**f@tgJUM>;-{baW(feQj{QKy?uogM4{fTd$yl|3B z=F>U36JIiKa!nPODlk=Gs=!o%sRC04rV30Im?|(;V5-1Wfk&+Ze_Y@F2EN0r&+qT= zfVLVRTKBSa4#1YA0LFzftw+k+e4>FD)-Ig7eS5AIpOr|`vDQJR%$k%1#FG^w3)F|v-vFHsd4>QDO|tj@>zqYi8o5O zO6q~**WnrB%eGWf8m_-)8*qhqt89xr*I&MXXGgxRm6C?*FF%Cmh_6-Cw$gC@L@?&^`_`Z{H z>EB<%E5uh_jr)V)^y9C=tHigu!TrZ@diK}hD)DvK;r?bgz4;sP8u3OCxPKZ>Z*u|L z#1DOj`*X?ZZ63lk;;qSX|1UYc%_Df7c-gC3$&%CCJcc)juZ=OSEIGZ+6L^z&+)WBA zOHOa|6y74<^i7BBb9$RE;5zZW=^D(R+n?u4*de~@hYIV%=`#@UHt|@>5_wLaK?pa9 zZ-+u-KAb*-2qf`&sSCVbZa)lS$cWE|GRJyydJYoE$9&2vL!Q%fkU}x$Gc*$O;q)9V zKoM`sPU7`)dJdMLi7)Y2h?JJovk+j2w>EP;r)T_`RT5vx0`sw)o<#(f_}Xf`Ud!oO z#8466qaduboSsDj?+~wSh2NLuexHaG-X(sJ4eG&i`WFkhIp$+K)SKn>FP8A$n2#J# z&z94_ScCV8msN)SVmbYbb+|>m&I;^D%jsWiz-mPk@=9aFTdo1bCaiALgxb|#TCM{^ z0joPSp{;7%f-KhpVF;@aXhM^nM>TIE3ON| z1XjB=!PW)-8K}562vfWfn2txi0%9NVf3tApY%(}IzenRkXG5}yaAS}B^Ak6Yww+CX zg$(Zq56E-uY;f0Ef6LjB$k|B#`i;+4-Tf=}#`|88;4&osEwuIyk%d-bLem zHx{FxNH`^Omq_7kIPzC$wG)bNIV*_qi4SS6M`XI~qQQZ)3Hg%~H}($6PtoYE8~aDj zrh9JXXpcO*&d!dVjSk4OPafjMsT(Kvob`mWA&rAQH(q?=)|t^5Zo*fihCaW)`Q<-k CB*jVq literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c1b1.dat b/war/derby/seg0/c1b1.dat new file mode 100644 index 0000000000000000000000000000000000000000..ed5563fd053181c667a9114e2496fc99006059de GIT binary patch literal 16384 zcmeI2JB%Ae7{~wK$Lzz8bHedT!Vx5tRF>AyTPFt?2uXw@1mY2dgcL596x0w94G0NJ zglH(JXaLb6T7;-*p+FHdfJ8%qBBh{)`99ls&h40Z_zD#Ct>nLVXS_e}{%6Ls|GC2z z05$ufEn+pSi!!fYEVKK6&9;5TOAnv4HLuuL3bf}Rs@X5M$N#vUa@B@EUwD36zQE#w zVP_+4yXg_fI4vNIq>#}-+zo( z?RC%d{mY=Zyj8iAdHueM$k^x};9aDa?`>#jG~8?}5FNC-5v@ znAN?-Wj4(JYIo*gJ;2Eb$8i6}qT4TvVy9CSm$y5;(O}#uHZNVYhqQJ3gUkH_>p1xI zQ|G!pd))2zY+*6(^${Xi+vU+0>!uE<1L}Y}pbn@5>VP_+4yXg_fI6TK{Er;?67(nd zExb0pr})#Of8LP)U&L`+bGCBFOY%QVVk7%Ii}8PUYPg%O_d@?(g10F@3HL|%vNPNs z_B*}uC7a`?5q^AWrz{;2z8n=c!q*a{BFZLHQe-kpm#!s4E~E5_lA|u8(9%Y&j)sgf zAW8#G8D&V6CR#Geh$tqp^;<`VDg9zLqjPsm^>=O z&{#?mOisx#^dpm`m^>!J@T`<%n4Fejs0$}KCTCcdIB@-(Xj>VP_+4mcdJKgg#6 z^9}18tOL^c8tZ4I`A0Zo^%>SCY4$Dao2(^idY$!i)*U)4-5^bVWc`5k9BI7GdW1B( z%KAR*n7loc6!@48?dr_#R!-gaOdr`Qhn~wbNMWIJ6 z`=2w_{O>~MwD+EdQ^VmU+cA&X(o>RVmb8;(S^DUzI}rC9Vte|A_iaEY1HT z>MyZ0|BpCY8XOhPMVP_M3ptQ*wqIp6;lIrP&z=14r@sNY CQ^H>W literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c1c0.dat b/war/derby/seg0/c1c0.dat new file mode 100644 index 0000000000000000000000000000000000000000..c5b91e2c3fef26113800b2a821fa2bb19fdf1105 GIT binary patch literal 8192 zcmeI#u?@m75J1tpC<-o8(9=Lg%K*#}rA3TD3rJK@(l7zbumejVQ7{4=PD~;b3K|OZ zBiT9MS-$vnk+q1Zjpvj2IrDRS3iWo*;(Pr>>5t3OD$A-0<9P3_pmW_xQUDh(^bLUeR^QorsGgwRhxSeZerK=R_$3sS&>;9{Cwm(lE17DT= z%L&7~e#|&&;?Fg_>sjs^8XE{e00Izz00bZa0SG_<0uX?}KN2_`w?@`_v-rTyTvWW> zHRjuiywH)sUdnn9&>7WL@ttpEWNuzHRmj@WgPjG;WDzn~r|3|^1{ee&009U<00Izz X00bZa0SG_<0>2TM%F-89r%Uez@u)7| literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c1e0.dat b/war/derby/seg0/c1e0.dat new file mode 100644 index 0000000000000000000000000000000000000000..761408d3b3483e2cb3bc4d3d46e37c5e92d2a255 GIT binary patch literal 8192 zcmeI#u?@m75J1s8gMx)9XsIY^8GsoOEn*EoqGJIjUU*)|)wt@6|}sAD0WOtjp>!ZW>r~9~a-eZ+^K-&Z<6h zQdnN6BCjSb=Z2ns-%=rk00IagfB*srAb<{9 literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c1f1.dat b/war/derby/seg0/c1f1.dat new file mode 100644 index 0000000000000000000000000000000000000000..78d701f45559f9fc67104563ad350118d55c794e GIT binary patch literal 8192 zcmeI$Ar8Vo5J1tHinfv?;3`3(uvmiT2xuU|VUV1F8*mCvfUHJ>2!By+fASA$XZ0yu4*JMrY^=I)Z?7ZAN6=ie_YP2va~A~>4i;dhuiw==sf;7y7m22 z(YsutxY|vJ(II|cE4nlDZ7atD0R#|0009ILKmY**5I_Kde-zjsHYzLovhahQxLNl0 zt)c!}NHc30>?Cg*0iCnvsqmk#GSJdz^HDNzv-hY@dPc6MhZ6SB28$*T6+vDbu1lw@ajhFXL) zX<|hAQxdpC!?jHzgr0gpsltUyP%2JbpyE`i2cld+LZXpC96-SLy_x5onVor_H}c}$ zGGlqXJ2U(C&F_8hd*AQ(eID{PLWlytxJ|PC7~6+;{CxNry#7zH#SW*wU4b(<{Idu7 zMF-%^C-|F`zo(LpzulPonSXq%t)QDH{shOzC?R{`?`YCz;TZeQ?Y=nWv&G>8fdYX7 zfdYX7fdYX7fdYX7fdYX7fdYX7fnh@6!7ny%kxl3^=l3&Y8s0tGa}WG{?8N98eDWFP z523@y;PnJ)z)zE`lO<(8S%TMOe1d$6eA1$9>!_4=sOohp71eM%7QCe`_;ECw((ZK{ z6<)`=yGEWSN7pW_%`Z33EG{qAR;$h0+QoWfq4ouhC<-}sNBN#&L$}7Ev->u#blk5u zU%u+Xo4wCAS8FwRG3vChQspzO>u}9i+?N;KD__3x0z0I@1!Ei6tJmB9CHVdm8`syb zY+T!P&u`p#VPW&?<&AdhhTGV@eEB;23?e$guh}{>{o+d<_a(P8|KjD%uU_%5#MVN$ ztc!2Ce<)VdQPdfV?*u6BgAOO%$exU_B#(d(u$Brqj!^e(cf3Y>fJQ)LBZyrKVO$bo zysv*4pG(KskhWC3sn~t~Pc5}9L~(x}6wwi+`vpGVuaQIKAk6n>_1VSfL?09rMWgJR zC=OKA7i@2$Eg=$<{R8(_0=WMCm+_(rH@GvliLE3#A3PqK;cX#&2lBw@3Y+A%d6yg} zvurI|TwiKLR-r*LPBh1^aUyV%#;J>!<*ELmdp`+XdF#ZWWmi0B*)r@l)tKkBRo&8U zwd1uh8p80Wq-iAxf2MQbr*9KBKwyL0`vHDy^Ji;I)rfV<%d#<4{x(C_LmVq@ydNL2YwkN^<(5Hd9o)`KU=G=03!I)b>VtN=x=B9bTV6bafuux z)7|hQxp(5G4&~`xwgu)@GD~Jc3ruqNY$14ub967Ghj};X9``WG-4jPQzOO3wAq1u# zlOGW>wTk-#56By^pCNA&vj2C=DMI%B0QVEixF370e2I{~Z!4dJ%=fzTJRu`9%4wjZ zZz&yU(8bqej(i&Su&F2i_SXpipC(gq_z8A0yo0Hkv;qImV@saUJcC#YnERHuSZl6U z>y2ja6>FD0uAvEUIFB}>XTxwd4a33W^n1bgcVp5KcqbW?8io+ziT+vX@ic^oj?o*Y z5W_sWNH!}aAA#a{*pCagW_sevVTePQJfedkUMsmXss>TPbF~XY>xCTQ_~sE6GJ*%B zh8%$LW#Ap1Je)iuek(!5%6Tqg5RE-b=7vs#aK9GXmU)xr%4fhTrP~@=Z9s3BF17e zEob1{1BI&^rB-Yj%PA2(O^VRH88|MEZp?8dv{f-XDBXnyKZ#Qo$I=j(`jGMeSCHXP zo@C7bJ>^@#|DVC*fSIrQYiD`Ns=ARM0cgYNyf|%P!FE%;- zIt)`BH0B}ArkJ4dsN!*uWrRG${By%Pwx(DF&cl~8!uQ93j0W%}53ZQk=Ap`_m_P=D zyN7E|re$I?zgSFofZ%B zgZs_HpF>TGAUu}>;a~~eI0?IPevXQu5E{TjJ07k*A%l`r0D>~iY&J?E9dsyaqlvR9 z)Wfz~rVg$@p&rWdBt!=a7 zs!-?Ta`jQt-KM&!mMqF=A`}?up=onBnApwL`k6De)!_@nlkb*~Zg970WO}HMPu)?f zkpCy-4lw`sl#`J8_mnRJ^ZyO`31t4;ki{V5$CP=<|9>0V{$3l|{>b0i{yf$T?0E_+ z0+erJ3&8*3HE#FT8XqL^|Gwq_lSeGYKJO>m=f`GUPsRfCU^x8)>y;A-lABC{_t%N= z4wgI`Eu==VG+Gyc$(>l%h%cPUSRkPb!7C?mBsZA?@2k9!ntRun_fKvNE2BdFlhY79 zOLHk@wRos7aKT%n+ zloh)Uh^OPWSh(1|j>pX(1v1jY`qI(`?P9EV@vnrYJlAEsgEeKf;Vb3nyJMAr{c6yL zMxjqGln*$Ti8O(`;30giIoh1Afr5{G7p99Y|KL8XobL96e; zTDsbDH7wI)n^&%Q7Lk)LqyW5@2;dO8FN=m(fE4#7C$UHYc#7vaxpRm)uQIKaV37x1 zQ!qn-r_T`bW8nY4LKWb^E4bhPNO=wRRmT7Sjm&@i9mfCXl3x zBjEd2m)D#129#(1--Up*Y+6)f(?2y_mQx6%2Hukv!G)#X?gYEY>vC#Qa#$74YM87Fd7 zwd<$SVUjDBkV5`pkfRDAKUgX;uSibAR-j^qV(4^iN=F?N z*fwe?>0h8k^nji1^DJW|=N3V^(G1XUG^3>11|6J-=LjrPVVqcZ;Smrh$_oID$Q3&a z;PFHN<)4#<_t_UkYC8a32Vyn~b65ain7I_M3j{uf2u%KvsQ~A2zwZut0DD#)FwUw2 z##nX0=wFm?fC_My{1jAx5v=)Fe#t8T=aldIkW8O`>*)ypKf)fFkIw*zZs7fsw$Vvg zO}fwZ+tyXJsNTZ7QZRW-kOgwgPRjap6I;&o3G^BM`ea% literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c200.dat b/war/derby/seg0/c200.dat new file mode 100644 index 0000000000000000000000000000000000000000..c3a7808dd76bce2cfa24ab40d4e9e5d87dc76d32 GIT binary patch literal 8192 zcmeI$u?@m75J1s$1i=Lb3s50M%K*%PXb~gO0uod#zy$2W0xUtt2yk3-Nn}DnLxH}d zIQE_8i(i+>PDFysP}eC&nJma vuIq>4T8HfiLRaS1Ri_vsfB*srAb95yH6u_15*-aC4FwGwFa=XE155#DJC2+XkZ936 z$>;moC%?`o8xb+OoLH|juTvHCX-w^BDUI+)cdnV0u0o^}i;Ol`|EsjNzf2yza4NaW z2l{v2%qVFR>T25eEOxaR4g??o0SG_<0uX=z1Rwwb2teQ;2^`K_BWrzG{9s#eYevS+!R9<8rQYf;t#g zG2c#Pxn3FUrKm3gI%oA;@ju_l$Xr9z4yvrXdT`}uvZyld;R@Tco6!(J009ILKmY** W5I_I{1Q0;rCxNLf!~V;?yuASIbS~8Z literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c230.dat b/war/derby/seg0/c230.dat new file mode 100644 index 0000000000000000000000000000000000000000..24afa7bc0e8a5460d396fcf9dede407f1b5b2c15 GIT binary patch literal 212992 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 V0c!zk0c!zk0c(LaTY&ce{|BO8qlo|j literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c241.dat b/war/derby/seg0/c241.dat new file mode 100644 index 0000000000000000000000000000000000000000..f136593166d237b5ad733e0a1038d5c5ec04b804 GIT binary patch literal 8192 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 literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c260.dat b/war/derby/seg0/c260.dat new file mode 100644 index 0000000000000000000000000000000000000000..25f81fde784105363c372eba91f6175388235f63 GIT binary patch literal 8192 zcmeI#u@b>R5P;#mn}{nEdX-A+0X&0YhQeq(1ZH$RfG6-+YQ4@Qur682oG3I3^Is;H z&F;-@?&~635pjAyhmUg}=lW#zdQRheIg<3p*NIlvMYU^-I@&zg%Qw$kSS*vh%Fi5J zHSdNZuO#5CmTJJ{onf-wck!@^`wyH wy1wVmRobsK&Sb3DTxM0C2mu5TKmY**5I_I{1Q0*~0R(<5Fp_@J@zR0f6#Y9cqTpT@tH{d|bj(Q4xw3HM?<81yW zJlgjPFMJ!7gNPWtsu9_k*cb+14|6(y)}xdDxLjyur&lI2@SBV_*Y(%Y+rF4RM((NL zT{bbk>&;ApCT?FV+Md~|m1BVb0tg_000IagfB*srAb`L>3S6#7BYXWa|AQUbS^D;^ zzTPb)sU8`eC2I}>dS}g3{y*Qy)RZn8ZR={R_p1F;=CZ15Ynu~^Z!SSZ009ILKmY** W5I_I{1Q0*~fu99(*|@z$K1^TR&n;~L literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c281.dat b/war/derby/seg0/c281.dat new file mode 100644 index 0000000000000000000000000000000000000000..cfed875dfceab65004fe1b91cbefd660cea0ccb7 GIT binary patch literal 8192 zcmeI$Ar8VY6oBE^iER>v#vwtWI0HeW&}bmRfk1KsZonnr0Ml>(Y%uf+c^G zy|wRkYxcQ4S&N9#%Z|jw)WtZ2dYsewvmA}|$K_NjOTBWDPS|Aha9w{Lt;e56kDh-j zdY4P|?|L)C=n%iJ7TuZoww7ao00IagfB*srAb{RQS&~GB8)4O?G9~wjOLRU?Q`!GItqmN?d$`hyVfzAbchAM`1#m1bdH?_b literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c290.dat b/war/derby/seg0/c290.dat new file mode 100644 index 0000000000000000000000000000000000000000..4d10db46799e9d59746cd4b6c1e17c2cf3a553b1 GIT binary patch literal 8192 zcmeI#F$%&k6oBEEAhn2tp1{%7#YwNAxO5Ql1g`#-IlRrIyyRnZW?ltk@ieG4FLoYKmY**5I_I{1Q0*~0R(<4FqA=2 IV18We?qDStyZ`_I literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c2a1.dat b/war/derby/seg0/c2a1.dat new file mode 100644 index 0000000000000000000000000000000000000000..8e2ed6afe90b6e9bab82029f98a338a3cf455bf8 GIT binary patch literal 8192 zcmeI$yA8rH5P;#cizFp%Kt~A`6*C}eBo?3sBr0eqk?5&tnSv>p0j7Y9ACVIR5-s{I z%49v}E?KxD-)~u`K-V?%Zx)KyfWW literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c2b1.dat b/war/derby/seg0/c2b1.dat new file mode 100644 index 0000000000000000000000000000000000000000..2a2969247718ad8c76b895d72b43a1f781e3cbd9 GIT binary patch literal 8192 zcmeI$p$@_@5P;$9mTZ$e0uBoXg~t&L2Ez*=fdq#^F2VB#I9>*g1jie|tzDOH41y+q zlik|8ZkK&-m5qoPy^0apnAjKwUk`ISf0m<>{?NxX0$OL)Q~p2S$iQ4&HaeHpSnoyqnM`C})($o&5?@_{hyVfzAbbTe~jZ7z9oJ zP1cXQc9;F!Dk~8&`s6LLePa8t^Z78Q^Jmd&;g8FSW)}KnA}znkXmMSCZH?uR!&}## z3f^S{y{itU9~5!>D!r|lZ7MMq2q1s}0tg_000IagfB*sr{G-6`ur{*PFY`axk)5S) z-|F-AM3U;2!B(>JBA{_rp7Q_sMh52WqS2|y#yZAYek>iC7P-BS`ISU`aRGV+5I_I{ a1Q0*~0R#|0009IL_*q~ibGNsBpFLh?bT1nK literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c2d0.dat b/war/derby/seg0/c2d0.dat new file mode 100644 index 0000000000000000000000000000000000000000..4adc6e4470f86182da42ea94fe6881290c97948a GIT binary patch literal 8192 zcmeI#F$%&k6oBEEAT<;RZ{Q#zZXTdlP`ZlOP{GX$cmgjaNLOb!2M?gnw6P`D!No!T zl)k3#g}mn5DjN|odOwHtG4Zh(LcN*O`MnxZ`r~V^l~q~ohebVY?!wDA&#PN3qrIxn z9A7kVrXsH@rJ7uUx zg-)XDhvrnL?NR4W=KdOJoJnrdy3Py%1Q0*~0R#|0009ILKmY**ek72|r0jG%7o!J8 Ck`^og literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c2e1.dat b/war/derby/seg0/c2e1.dat new file mode 100644 index 0000000000000000000000000000000000000000..b37b9b254234c4de527ff90f13f4624bfa8f98c3 GIT binary patch literal 8192 zcmeI$Ar8VY6oBE^E!ieH0*(X)2E`c&nlm7Q1cyO#0ult0)1YQB;NTSS)~-u820@d* z%U;{}x;6XUDk~8&dKWFSF|jcWz8>au{484|{c$?g%0ll90R#|0 a009ILKmY**5I_Kdp9RJ;cWW<){_zC{d@qgw literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c2f0.dat b/war/derby/seg0/c2f0.dat new file mode 100644 index 0000000000000000000000000000000000000000..d854b4b482d64363d5e58c63e9e4d8e5633ff2ec GIT binary patch literal 8192 zcmeI%F$%&k6vpu{R%!(Y7eR1yarFS6LEOX}cmNgLynu_2p1{Ssh?j8m2Kr1JTWY&H z$Uo3Dc`wZ)zpbq{lAK-d*6@Ao`(hXJ#h8tsSu2HWr!&i}(rh;@>R9n4Olt0x<(HR3 zzqD7jZgjV}8%v)e75n;{$*v+p2mu5TKmY**5I_I{1Q0*~f&UWNpSDhGJ5zYUj{FyZ z@7M8=FCD)b+mk(a%fpR_-)$f}$Mf(7jh+<3 literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c300.dat b/war/derby/seg0/c300.dat new file mode 100644 index 0000000000000000000000000000000000000000..2053e0105b40818ea4cc1ea3a6c1cb5edb9972df GIT binary patch literal 8192 zcmeI#u?@m75J1s$K*2&3Y>^6y0a$=0qM<`c2CTypbc_HOCr5$_1qBWI zw&I-cEIWQ(WGf<0pQ0sUOvBh5tlrFNe6L!R{y3d!WnET>wrHS-dz*aozWK#6+N=7^ z?5cS;7I_}hvTr!k?^`OQ5I_I{1Q0*~0R#|0009IL_%DIOY3F34ce4NcBt*TpTUtFT zbW>fQxl5hy6k%U-nQPBqdcBAU0R#|0009ILKmY**5I_I{1b#0tkx_Zb>Nq_=05p*m AuK)l5 literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c31.dat b/war/derby/seg0/c31.dat new file mode 100644 index 0000000000000000000000000000000000000000..c89f7afe22acafb1b1408d1094459cadf2b57368 GIT binary patch literal 8192 zcmeI1xs%*P6o;SYkVbRwE-YX!17^)(;nv;alsOiRv7rbYkd3Z@2qE z>LMiaKLF*B3>U;ynGoK4+M{P@MjcZnZOw0bTHot_{rYvcW)^M$fPpW%I;-G4s&?zg&LX^Sh)|A}vgP&!#-&wc7T zUSro*wGn6|&_geZT)0F5{;U zSH@wl)YKKGg+Cd51B2rq0@jv}jgP)=8*tIMdsyopzSB<+9dzUxd~#TG7T?LS&Mzod z2ln8c6m+?sBSaybs)%F9FAIqu#RC5_HxUB5U|29v`9Q}Hz*hN4$J;Pe`Gt-j!bs(F z9Y2Dx!h1r;k72@mB>f~8F8iN2p7au@sPY2MDL#Sg26cQUFjd>v#%BsMmDk2+26L5< zb^gy`OXX=o8|QZmwpBjS@!PPY^4j^@fd>@ccQx&IOn6Y`eI0MXuF8ixegF@tye|G7 z8y;5qOxOMp9#MH+es)H1M&Scpes;$2sLJcsZ)XCJsk}CxQ+S+t%zYpC2uk=Oc8Ve^ zoh(UK^1m~KCpPhUP||cSt(VRmp4`Oy!J=H@x8Ur0zHs8OpyjsQ{x&?te7(N~75U$= zzjaM`TH!-o{JR!Bqw>1-)g8b&mDjDWt_{zsJjcJu{~_$Dymq`JIIr-LcD!SFPT>Xf zuH%MP?v%yiXnyg$2zfv3PT=|VJmybPDd)=}KZO_8^SKj=jKW3pd(!?4UR>dQr}R9} zS@+(t zE&asFWJ$*#U9PC`Mf?~d=B4m30xl+`D{?3BqSDF3g!6|CDw+V|ClE7VNf$@tVm=d} z*@9P?Umovf|F_{)<|7dY7*E_En*G^<*J^)66iVT;KMnEkoA5gGfv933 zBu*&%pL>;)%YyfF8bB5J3yOc=f;X5y$)Cpf_Xm)sY~aeUM2B#NG!CF|Lwf1-2r!Pm z^w3lm73OwTm0lcXUd$d1A$^k#lqqX87(x0L8$@1GNs-_oS-Pps#NZ(-tk%gFbl*X=)WAI~KI*Ffg4;5__L77lgr$)M8kHIVPv6a?gv%$lqh#7f`oUV4HW^@QTwT`##=yzKVr3poOpR;n zde~?%#xGEzt-_jfM4Z?5tq+U+1{t}=v%J8LuGrHba0!rcb}E(`+HRGU+25E za*f5z;3m~iQf{ZBvVDWpJYcQM`&`~7?cZa)&3coxcZ;=RjaW_6?p@Xc)*Gz*th=P0 zd#txvZ?axz-6J*bv)*E@SR+=G6z;MfkXp=G%vg80h8dF?i>*dK^XRyK{56#gCP#m9 zJ-0CVmCBRPx#m8#Gya{*qwA#OE2PsN>EuV&8R=+`$iY2Qn|p*;;nRBdu73Z+-~Rz9 CulO$j literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c311.dat b/war/derby/seg0/c311.dat new file mode 100644 index 0000000000000000000000000000000000000000..f60c260f85bd9b0a9e1ac4fbc0967fb1521015d6 GIT binary patch literal 8192 zcmeI$yA8rH5P;!x5`~no0Ud25Bq~+_(au1>-;g8#yW>(rWk*+^vw7BlSw$}3J(Y^1U z3f^S{gPTq!4~n>Rwb9nhcC{EA1Q0*~0R#|0009ILKmY**{!!p?+!|Tym-!#;$gVnX z-|F+tMB33SgS}+cML_GSddmOj8yT9bi^jb&o9G;C`MFHBFUo8&#oCjH3os&p00Iag afB*srAbVZcRFqIrAO@g9)UwmeL4+bQhZ0=*mU9p~z@+^}kAM`^)&z^QWS_ zTwrk5&5WWZzOJTS&-_q};XnWa5P$##AOHafKmY;|fB*#kk-+J^H?q~2g%5V(tnBTr zA>T}-nT`yOl2?O(R;xM{{`p3R=IW!JewnqS2RjRx%d*Va%{ER7YatMT00bZa0SG_< X0uX=z1Rwwb2>e7~Dr;YVTTNy!_+>2u literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c331.dat b/war/derby/seg0/c331.dat new file mode 100644 index 0000000000000000000000000000000000000000..85ee72b31368516c6de9fbe3516e0e3229ea2755 GIT binary patch literal 8192 zcmeI$u?@m75J1s$kdl;)Kt~BQRLp=V5hG9o5*-bqVgfc`3T8;b1Qaj@ob5PrLO`NL z-;y2s&dJHIi)AAsM!Ri^8&fyNL&(Q5oj=Rg2!CA8G_%s4i*&;#qs4XowY8Q%j~_k% zR`e|w=->5WhEWl}uQs}x`K}gYfdB#sAbHq)$ literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c340.dat b/war/derby/seg0/c340.dat new file mode 100644 index 0000000000000000000000000000000000000000..d99b11a3f2dfe2333989898bca9463dfb265ef5f GIT binary patch literal 8192 zcmeI#u?@m75J1s$K*mB8Y(Rx*8GwQbEE)>L8i0goSb&C>ozfsN105s4;lv~|p`f8a z-%*^)o#l&P7ukr2(fc{FFxxQKr&zD&G`^Q3Nq>BuX=PPZ`*BfEo4fe(&GY6K%Ve+e zGe=j=o3Y5NNyEOOr`tDFNFjg#0tg_000IagfB*srAn;!Thtt-`TF(^!@3Rnf-cA|o zNuh0Z{lJ{7bZe@y6)$tWym-^CYD5SifB*srAb%c`MXo7z5=i5{uUv--&9MZ&vF5D`EC d0R#|0009ILKmY**5J2E3fuStizH|39egYK>F4O=3 literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c361.dat b/war/derby/seg0/c361.dat new file mode 100644 index 0000000000000000000000000000000000000000..b5c8f259d0d1fefc112f60325bfde24724aded2e GIT binary patch literal 8192 zcmeI$u?@m75J1s$kdl;$3Fs)HqM~2|L`_Fa4M=n}luW<|Ou-be0fLqV;B3c{69N(~ z`j&FB@0?h9T~5{_V)U{jaWQo<4xt|Bbp9+xE&Xvh)yh(@T%;W~89iLrUq|Ed$Kk!} zpNih)61|(=%pf|%@2f<2X1=ZDSRjA^0tg_000IagfB*srAn=a@`@_b_O1~`pU?*;t zy?tw_*9&Q;ErXrpWh0<*Rz4N}^NsY)*=JkxqH0?YwihswSy36gj5Z}sK0!nP0R#|0 a009ILKmY**5I_Kd9|T6S@Vl>_%i{&Jf-Z#s literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c371.dat b/war/derby/seg0/c371.dat new file mode 100644 index 0000000000000000000000000000000000000000..ad11f01b25b6bd995142e4d731203e66b5792409 GIT binary patch literal 8192 zcmeI$u?@m75J1s$kdn|b0v)1)ii&~>5H%AZIwU}%qoHI1HedoureFq`0?u|EIUyj? zqHie|`!3EYuZv|XB1SJe5*Je!;}Gg`PUp{J)Y2c9Gp(%k%0)WiA*0Q8{dF|9KaU<= zzbkr|OZ4t~GsCEff36Z;&wO9Wu|NO;1Q0*~0R#|0009ILK;Rz*j;EcGjec49!A{&P zd;8Wiymj?ljvvODX&o?qKH=k{-imE+&uzx(_;E%Nhw%^vgUgY%9cninec#S(sRbE;&7F z86zpPED~B-`>Tx7BvmYwR-rN4G)9@~_)_T5+Fxaqr6Np()>ff0+A>BR6?M6PXzi~u zlBpi?6Ar9GW3*kM(*qHS@b~Cc76mN)0lLM9f)xmW00@8p2!H?xfB*=900@A<9}uXy abj_RkM-%-#(wm7_CLYs%VKTmax%mQ{S%%sG literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c391.dat b/war/derby/seg0/c391.dat new file mode 100644 index 0000000000000000000000000000000000000000..e15720b578fd8a4e262feaa9ce3d9a8a30b1340a GIT binary patch literal 8192 zcmeI0zfQw25XR3WBx%dQLm*g)&^aIdjd; zBHFAL2|k?X|Jw3}c=^NY^F^_%rlkTqpWF#qJET~*;MJMdWFdwL2!H?xfB*=900@8p z2!H?xfB*=rB7w)3J3%*GS@pg*DSv8jEY(`&n+e0@FN1rs<{tsSj^?|ncfKH3d=ydb zsm$u!YkZL*op3uVvlA61(!Y3M>ikn+#KZmLqXXKeEhlk;NcxE_9oM&AH;in*@1EP^ z+~mk}ysS^_qz&RYmo~|22&75sM>6nQ3Ru)>2xO@Y6Bz_81v=Di2zY5Q_GB<>DbS@} zL%`1>HK4}oBcaFp0dC1ys%%vSPefVCj8bzwnbWMW0^ya7+qXJF<9 z;CxA{v<0%G?a8V#qYv(s?iFct8(wOL%Z(TYAOHd&00JNY0w4eaAOHd&00JQJ z9|=4@-zmD`lXds|fZSDkZ|AICemmg@{A6%X;rb!q$FKFQ?w+scSgo4q=&jAVrw5NW zaz+=aq3P25}@J%KlH^aKu0ZZ4idH*cWNmXd;K zoXuatqkXUN!nc7eM8xR%8j+2ujbZThFsJiJF>2|L%aK-QdgdZ+zsYEGU4I>o?RSG) z$K4e?%O<*4y_jCm#OV^ z%iiAA*XxBe(_aQ_$;%%BjkEGD|DA87Z!RtypNndu*I3(+?J+5;2b&d1?k+(@009IL bKmY**5I_I{1Q0*~fgc5iGIcwTt^MfxGuieXjZk45o7=7~Aa(&|ZxC{9>rt@dfYT=K|v1aD_WFqab$!Kw1e{GHBkAr*1 zpNih)0^OSqrWY0Q`zpPwnXM}^76>4K00IagfB*srAbheKZoe|J&@T%=*ey3p z-@Y~E>xm@QD}#+>K-rbX_gV}2!JFWS)%KmY** a5I_I{1Q0*~0R#|0;1_|R%>4F)Jhm^H*DqcG literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c3f1.dat b/war/derby/seg0/c3f1.dat new file mode 100644 index 0000000000000000000000000000000000000000..08acdcee31e218c5d9c3b4f62ef38fb0f42c8e72 GIT binary patch literal 8192 zcmeI0F%H5o3`LzHwH@IGY>Y55aR$W95tsqN#?p}!a05=kDL6wJ7&rkqNmHezAhDun zDX#M!*UH;s*@}qKWi4?&bv||>A8Q&vD{ILgw+qdzb>$-caL8zL-G8;t_UGws=&PcC zIbl@l$4sIo{#?Vmp827nv4H>tAOHafKmY;|fB*y_009X6BZ1>-Z)Br43lHqXMcLb3 zL%y9zGaVTelGlTP&Zw>m?|dU;bM2TM$;ub(?#18*9@Q?- literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c41.dat b/war/derby/seg0/c41.dat new file mode 100644 index 0000000000000000000000000000000000000000..697ebcb73d17281fee916323923e0b752304d980 GIT binary patch literal 16384 zcmeHOOKcle6umRg9)II+`s3FYLJPD;V~^9?B~ZK0G%<GyHTj>Es=i!hyy=t1jZpWJ5jwF#rDTPdIvPzopolmbctrGQdEDWDWk3Md7X0{4yr zU+#yq@DkSJ`TI*ic6n}Fh2HpGygL-yp%wPr$Vp`^1Zd*=}y;fF0_~IwchzfyS@U4V5VZqWmquHp;;IW zj~_2s7l##mYp&zJL9uF@AV4HH32Dn}Q3@yplmbctrGQdEDWDWk3Md7X0!jg;z`diu zr*H;~nS+;|l5YJG{^B4!Iu2<)9m#8F6(!ancBn73E# z_B>ym6x`<>(;fw1nIzmFNWxNO3LfyTSo5o`)>?5hf!#2R7N)S2z>X?~*}<$;C{@<0 zl)&OrtYR8l!2~vxfCmMnVG7TP)6Hf6DJ637kf*0Zz?MQ}V1EDwM+lLH6Tufv4ofHt zbHOZ}BP^7Ir#HU@ybCxp7!T#OXPlXwSuU1vR~CzUOfDh#a3s8HS* zuDkJixmene@p?F|oeXC2e?k8zOGc~J1Z{SM7a21^Dp0_Lao9XuDd2J`aCO zye{zytsDEAwiUZ7@g!mNFNtf!6U|Hf5Y}+rIXL0$!dB$f0Q25&Z zrsx0NK0P1_nC$=W%1`*-jk*6x0RCNIoN@riTHjp4izY+5PP6qK@ z(>}|VL`2|#cfEB8_<9&{P{3Z;jn}7cXSLsKyXPRADQv*QlbJZ`h9mIEWG0Tn;V8^_ zXX0(uF|RP;7(D6;-R)3X#Fr-yhXN>Ax+LIm00m2sBs}IFa!w&!C8o5;WhSy=S+k~D z#YY>ROyoF*ZB=Wq(@Z3s(w>mK>t<=4GCYrWbgWRRmM-p;*NDN9Al|ZR6$Z1z9naTD z_-{p3TPdIvPzu})1!A88{@3#OP-2oWQkVW5r2oG`UfQ@U@kzq)Z{*LzA4wcYJV0JO z^gS#hzAJH2qE4R|H>fQngE&fU{TGQJ(5Sv96M<<$?OWPzbT2%MbNEK$8-&pTeLiN& m(cdM0Oc;BSW~jX*lY$P^ux(J*05>IGp+sQp|Kr!Lz4|YYtFm(d literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c4a0.dat b/war/derby/seg0/c4a0.dat new file mode 100644 index 0000000000000000000000000000000000000000..de30561b173c8af6549ade4f3499bfa20ab95f1c GIT binary patch literal 8192 zcmeI#u@QqH6oBEEB3_CVDbhGWT1IggwYA6^Ss^o|&kQM2<=jFa!og8+YATAKJMhUv z9)2Cti^xHHY*h?>l;%Tv@-0lP1dZlfx8`CWSM6slesXjB#?N5h?u%tF8~S73M*Cvy zkZ()PzY6E~B!d6~2q1s}0tg_000IagfIx`?kKgetot`Yc-*3MEm-tVd2>}EUKmY** T5I_I{1Q0*~0R&Qk`gwoNK%x>A literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c4b1.dat b/war/derby/seg0/c4b1.dat new file mode 100644 index 0000000000000000000000000000000000000000..4a0bde24c0b75000754285355d0a5cdb93fa3305 GIT binary patch literal 8192 zcmeI$F$%&k6oBEEB5g;H;O3|xIC%&MCy(H)f}4w@yWk?Yxp@P@J9q{?g}x+BNoy5c zoX(%csHHzH$6A@|m5a2)CZmVz`s-*s{xp1a z{8Q1pT%vo|o9Rb~_xKmY**5I_I{1Q0*~0R;Y0V7p%#S?HIAAMC`< zvbS#y^?D)Av}Lf7ylezC&dR64f4-5Px%q7CTvToA!S(_sGA$|xm(ixg#V3deAb@ literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c51.dat b/war/derby/seg0/c51.dat new file mode 100644 index 0000000000000000000000000000000000000000..f71c8adbbf45ab5558cc8acabe37f5561f9d86ef GIT binary patch literal 8192 zcmeI1J9Fby6vvNjM=#6IK!D}7z~bexVy|A73=3#^1eS&6QKX==Y-t!OU?3GOp`oDK z4?vNQHbY63F94I0jttDuF%wES=h$AfiHYWv%;;wP_tm+-b9L^~)sgMME&yowqSj#5 zSI~Ews54M!pw2*@fjR?q2L5ju`1Q*6XYd6^z50It z0o=f&ch9WDI%8QFbOV1f_zKKBKLo7p-Em%h-PYi$cC@s0~nV1%KQvrv&2`gcN6X@ z^F>8|8amu7;tkjm@h03S;w`wp#0QhA_-%MV#JAx>nXk%!!+{4ydu1%ZgSAv_&V zk+>0Uoh+XQlpk!~1V4KuG=Cc+=CdTk9p&Nk%Tq|@Sb4J~k5{}Z&`!JqV-eqhSj2ZB z5%E2kFz+Yh8SV)znCHjehv!B70A3LBL%1g5H{rzvuc8>^$NF<_{2MyFB;pNtS;U)= zrXmLm((CMytDp##hg-(;A~#6<89u@0gFg0x-D|(Y3UmxhrX7+$qrHC7m4!1 zRY(bLksw>7wG@)BYv~Ppu0krtZZh%n(^=9jEqz<$fLr68 zbq*nxq%4}BxehvRjawoI2fvX0+stFY|FxP2q|OEK0NTH^{=oV*sq;PSm#jBQtu5j= zc34NGtrONmQge@$M@=3zc+@%~yS2}{%eqb4ZPA>apIEZEz-s@>xfi4;r;>l4_R-sWsmy>>zFM&+}BCrh;^UT zIAmongL#8_gGrsqPRgt6kvhMS+RWR`+sxa{w|8i?J)$}76V^jgxCS3DuHGLX{rT-b D8vyv^ literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c60.dat b/war/derby/seg0/c60.dat new file mode 100644 index 0000000000000000000000000000000000000000..b08b9b5a2edfb72f787d39ca6d17b5f76a3a97af GIT binary patch literal 12288 zcmeI1%Wm8@6o$|EI=;o@q;b=v$tJ10i2zEJEKT9fWUNeu%*Bx87T&bc6}dJo&}NZM zw%HWuOB5)&>av?YLV*GW`U>p>6v;9kEfKNNw z-(P@DEPZ_B`Dcz;q+xCWue{v&TdBQ`=kqXxef)?67Uy9Lu6ax(lNpTV%qVl$HF%MG zSY!zvso7=>x9hFwAnJ~Wz5Zz6hn?7uU=|wD>l?7V_6FEEgr*7{o_U!d3zxS|(?*xC{G!tj zI+2zOt}DH=>nF!DG*P`T0{=^$KD88(vt2t()vQAQ>)z5KZK$NQmQ?xQ%~9wFy`iRG zoK`1Te8G+FZPPNGq%B;f zUGRjb4%R9X22mVzb!eN@Ju5xK5o47W2^T%XWVUf}@u2d=-TlGfz&u<@6iwun4mT_> zk(#`|Qm!N)N>b|CIQS;6BqqcA7Z{{cuW%vxBIc!0 zVk#`xNiCN_<@Vu7%k3MNBq-w?hpa7zj3bD<=pk*MN>C|cuU)hOSCfGsMV+26Tq9Oq zGGr96jFfw&VP|=AI9;p^U0Aw?^2S4_qyQ;E3XlS%z$q1I{t0&gnmOFX{qg_sE#}YQ z0p=Is8-Ru1;2!2T#QFR`!an~{w48e>EOS4>Bh0r%o7q2veKv&q_<#4mGJh)WJkt_w z8b1q5<1>-NU!pyH4c}qD16QjDee!(a_c!+c;?H=%m2o;vejk{!&oyzckGuPXS&4Y9 z8n3rDz9*$lPV4QITvQ|lNC8rS6d(mi0aAbzAO%PPQh*d71>U6sJK|RZk+QEodGrc{ C_6?)} literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c71.dat b/war/derby/seg0/c71.dat new file mode 100644 index 0000000000000000000000000000000000000000..a4c7b89de878e5dbd3f646c303fabd21cea36070 GIT binary patch literal 8192 zcmeI0zi-n(6vw~LmF9PoHvJ6)LI}iQ$w^u@5x?Xn*I+faBiktoOPe2*g#`(a*jN}@ zU;~v6i9ZN+U_fjzurk9tH&;a^Al-)0U6g10-Mt_8Ilq(6cnZLvzi5eA&cJ^!^WPwPGUksIqLe8mH=exr+FO$3=@AID5RpVFgM znt&#t31|YEfF_^`XabsmCZGvu0-C`8Md0PzX9k|ooaFibBE*sU!f&&b{bxI7lk~~p z1yZLU0;b-bTFG<1fwFNt);=0v8C?^UNEaUNjdcgH4q#vCCdsgXV%Q5CzSnB|E)VR8 zhq!{vH7jl-)3QdEc{tkIGOPDTHF~uA^c$4xmIVeQi4;Q?Y4Q=-+if-D6w(YiWa0$c zUDs0zokm7lhmAYjwUw+h$TIq3GIuihFbZtPiLGtYYB@Cd1NVg6gaIG50qxVh^5KgoiK75N)DE=EZH}^uG=e% zG96mwDwV1z)5Ds%IoPb4m0G_p%9L8UP9<9tWx9+N89gr34i8+V=qp&2vv2rqW%E_6 zG0dYt@B+UZIUc?BiW#h7U9Mf=E3Vx-&c~(d@-Vbpd}4#M#0FO}2i4l4xiK8|#~a*6 zxiXA5xP;taX}8o(6VL=S0Zl*?&;&FAP2e9Qka&k1bgDhZZA$7pZUQr}VUt`ElJ$f% z9^e*mu7n23Ju%++itE(7f^Cv-gl1+>*d{KCk;Z$W#|Jd&{+iItd=&l@pW-nGvA0*k O16e*ifw6zI|M?g0UPQY9 literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c81.dat b/war/derby/seg0/c81.dat new file mode 100644 index 0000000000000000000000000000000000000000..88bb79d72314470c52620f67686f50a2dd998e9d GIT binary patch literal 8192 zcmeI1JC74F5XWbeD9OFwxfcfwIw}i$y$`QMO^KkPpkg<>E~w!oIw+u{r9n_o+()3M zqNKc!fcOH?!p!XM$#)6a9@$a;@s5A%9sfOw6bH@#Aiy`Z9_x_Rm3G{XVgFClu7&@3 z`4C5*<9iIS*+Kz69IqF)$-L2zzgC;LGZ%w*e&R!?d!j@?&bX6L> zlsUc%l}QPG2u3h=c>)&lV_0(es*7KOWrq*LE`AwST;6u^E3oSDI_u(BVa??`^IwB? z=BH9=^t7b;Q&E-$_RN%SCqE;lqT0`O*l^~Lm|x`o25dTfoOI>C30p2-bn#oT?eLQ8 zK?xPxROCfUmrXsyb^hD1GsA09g}8Gj)wCT~>t_dcnZN4KREDvLjHK;o{0Zy%cVUlt zYgEoW7bpBfaAe??pxM` hbw~;qtmmY?AFN+U2h8_*bWoG`;8~sV=TDEm{{@wd8QK5< literal 0 HcmV?d00001 diff --git a/war/derby/seg0/c90.dat b/war/derby/seg0/c90.dat new file mode 100644 index 0000000000000000000000000000000000000000..d78b8b5252763799302c9517976f3e239abd307f GIT binary patch literal 24576 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 DW^qhE literal 0 HcmV?d00001 diff --git a/war/derby/seg0/ca1.dat b/war/derby/seg0/ca1.dat new file mode 100644 index 0000000000000000000000000000000000000000..593fd882d200dcb9a77b7de488022e12c3272f4f GIT binary patch literal 24576 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 Aq5uE@ literal 0 HcmV?d00001 diff --git a/war/derby/seg0/cc0.dat b/war/derby/seg0/cc0.dat new file mode 100644 index 0000000000000000000000000000000000000000..226872006d7e7681f9732c7e2268f2312c42abd0 GIT binary patch literal 8192 zcmeI1y-or_5P;_d`8^c1va&H+ZL;?R90n5+qGABigF-C~aPS0bv@<4_))u~qrSS<& zd;v=n-$9){Zjr#!8#8-h*qynL-TN{P0G9xu;Y*AeKSumG8f1Mmhx6}XjHRb88(29X zRMYY%9XF53#gzA?Dt~fYD-QC*&kByY{(*Uo0}Kla-rqBJqo`1d43GgbKnBPF86X2> zfDDiUGC&5%!2dFE|9Gvz1wNDfexCvzSBn!*DeGf}a0JO^?QJCejPnrGp@kPjL$C&` zU2a$o=N{v{@32fKV=>cd=W!{9k?(nqgFgX8++(-0U4vN&6&nqR`7Cl`2-f4Q@8xpL z!uti=#;arGITr-75{yr5+F@qaHW<(Kx^h#??pr+Av{YL3pOymKmp?&Y+~H=qb@S= V>ckx5(_g!cb=gm8#4RL|*JS^htr_`8HUa5uVga3OcH{e2zUYA=4frH#)9JYPlzHwdPKfWqCh%J%sVHk_ACea_xGdeB)w ziqlMaG>Qx*bmO}+CGe7yB-}kf3677z#XL%)s2iYc6FTjIDrHoxvX}N%si5kj3|~s( z=`Msvy5C)_a3a_Md RtIj>O58!+O>G0`x?-%c{mUjRE literal 0 HcmV?d00001 diff --git a/war/derby/seg0/cf0.dat b/war/derby/seg0/cf0.dat new file mode 100644 index 0000000000000000000000000000000000000000..04b10fd0a8b7a245a6f5820dbd24f575377ddf72 GIT binary patch literal 8192 zcmeI0u};H442FGBwH=CtDh5_0M5mK{$)ySsD;uhU5D#!ksCWQCV&er^SebYMUIsC< zGV%uCyYx^LQXZiC9mP4@f9?3&Qo17|CAYV&;D^DtU97ira{gXfC%rZ-q;k_#ccW+` z!^bgL^Xwge{ra@u>9x|$J|(Z1=yym@-!OCh&{IJQ1V8`;KmY_l00ck)1V8`;KmY_b zi@@Xay`o#$DSlv2!#@B!f3}SEPGK;VUmmEpR{BfMBU;FH8T^6@qREJk=+JU%b2gb~ zlV&=VP?uR<>ZLb!*4V3KuXCKZN;LoK_Go%>er6KU8Ds5SdK;!~QiX4kb7PvhPIQ^( zOKq##NyyGmN-7TGQyR419Y+uV0T2KI5C8!X009sH0T2KI5ZDX?6}`wJCp2r;`Ix_} EA2wb$egFUf literal 0 HcmV?d00001 diff --git a/war/derby/seg0/d480.dat b/war/derby/seg0/d480.dat new file mode 100644 index 0000000000000000000000000000000000000000..bcd2bd90dc21ccb1f1555db2dbad7060d516aa18 GIT binary patch literal 4096 zcmZQzpdSbTT2%tX%nS?yAX`O%n1_LpfdjAut*O iqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3^-5dr{F)&r{m literal 0 HcmV?d00001 diff --git a/war/derby/seg0/d491.dat b/war/derby/seg0/d491.dat new file mode 100644 index 0000000000000000000000000000000000000000..e2a673b1c3a42775bd5f6317d08151748d1f8ad7 GIT binary patch literal 4096 zcmZQzpdSbTT2%tX+zbo?Fk2ZJ7#TQV95k8{%4b3o2XomnE+51uJ}NdE0;3@?8Umvs gFd71*Aut*OqaiRF0;3@?8UmvsFd71*A%GDA021y3?*IS* literal 0 HcmV?d00001 diff --git a/war/derby/service.properties b/war/derby/service.properties new file mode 100644 index 0000000..d1ac2b1 --- /dev/null +++ b/war/derby/service.properties @@ -0,0 +1,22 @@ +#D:\Work\Projects\tomee-maven-demo\war\derby +# ******************************************************************** +# *** Please do NOT edit this file. *** +# *** CHANGING THE CONTENT OF THIS FILE MAY CAUSE DATA CORRUPTION. *** +# ******************************************************************** +#Tue Jan 31 12:13:41 CET 2012 +SysschemasIndex2Identifier=225 +SyscolumnsIdentifier=144 +SysconglomeratesIndex1Identifier=49 +SysconglomeratesIdentifier=32 +SyscolumnsIndex2Identifier=177 +SysschemasIndex1Identifier=209 +SysconglomeratesIndex3Identifier=81 +SystablesIndex2Identifier=129 +SyscolumnsIndex1Identifier=161 +derby.serviceProtocol=org.apache.derby.database.Database +SysschemasIdentifier=192 +derby.storage.propertiesId=16 +SysconglomeratesIndex2Identifier=65 +derby.serviceLocale=en_US +SystablesIdentifier=96 +SystablesIndex1Identifier=113 diff --git a/war/pom.xml b/war/pom.xml new file mode 100644 index 0000000..faee1a8 --- /dev/null +++ b/war/pom.xml @@ -0,0 +1,443 @@ + + + + 4.0.0 + + + be.dabla + tomee-maven-demo + 2.0.0 + + + tomee-maven-demo-war + war + tomee-maven-demo-war + + + + com.sun.faces + jsf-api + 2.0.6 + + + com.sun.faces + jsf-impl + 2.0.6 + + + javax.servlet + jstl + 1.2 + + + javax.servlet.jsp + jsp-api + 2.1 + test + + + be.dabla + tomee-maven-demo-ejb + ${project.version} + provided + + + be.dabla + tomee-maven-demo-jar + ${project.version} + provided + + + org.eclipse.persistence + eclipselink + 1.1.0 + provided + + + javax.validation + validation-api + 1.0.0.GA + provided + + + javax.ejb + ejb-api + 3.0 + provided + + + be.dabla + tomee-maven-demo-ejb + ${project.version} + test + tests + + + be.dabla + tomee-maven-demo-jar + ${project.version} + test + tests + + + junit + junit + 4.8.2 + test + + + org.apache.derby + derby + 10.4.2.0 + test + + + org.dbunit + dbunit + 2.4.5 + test + + + org.apache.activemq + activemq-core + 5.2.0 + test + + + org.apache.openejb + openejb-cxf + 3.1.4 + test + + + org.apache.cxf + cxf-bundle + + + + + org.hibernate + hibernate-validator + 4.0.2.GA + test + + + org.slf4j + slf4j-api + 1.6.1 + test + + + org.apache.cxf + cxf-bundle + 2.2.10 + provided + + + org.springframework + spring-mock + 2.0.1 + test + + + javaee + javaee-api + 5 + provided + + + + + + + src/main/resources + + **/* + + + + + + + target/classes + + + + target/generated-classes/cobertura + + + src/test/resources + + + + + + org.apache.maven.plugins + maven-surefire-plugin + + + + derby.stream.error.file + target/derby.log + + + + + + org.codehaus.mojo + jaxws-maven-plugin + + + RequestService + + wsgen + + + src/main/resources/wsdl + be.dabla.service.impl.MessageServiceImpl + true + true + + + + + + javax.ejb + ejb-api + 3.0 + + + javax.jms + jms + 1.1 + + + javax.validation + validation-api + 1.0.0.GA + + + be.dabla + tomee-maven-demo-ejb + ${project.version} + + + be.dabla + tomee-maven-demo-jar + ${project.version} + + + + + org.apache.maven.plugins + maven-resources-plugin + + + prepare-package + + copy-resources + + + ${basedir}/target/classes/wsdl + + + src/main/resources/wsdl + + + + + + + + org.apache.maven.plugins + maven-war-plugin + 2.1.1 + + + + src/main/webapp + true + + + src/main/resources + true + WEB-INF + + **/*.properties + + + + + + + + + + + default + + true + + + + + + + + + + org.apache.maven.plugins + maven-resources-plugin + + + copy-platform-specific-generated-web-xml-file-to-web-inf-classes + prepare-package + + copy-resources + + + ${basedir}/target/${project.artifactId}-${project.version}/WEB-INF + + + src/main/resources + true + + *.xml + + + + + + + + + + + + tomcat + + + + Web Service Servlet + be.dabla.servlet.CXFServlet + + package + be.dabla.service.impl + + 1 + + ]]> + + + + Web Service Servlet + /services/* + + ]]> + + + + persistence/em + tomee-maven-demo-pu + + ]]> + + + + + be.dabla + tomee-maven-demo-ejb + ${project.version} + + + be.dabla + tomee-maven-demo-jar + ${project.version} + + + + + + org.apache.maven.plugins + maven-resources-plugin + + + copy-env-entry-properties-to-web-inf-classes + prepare-package + + copy-resources + + + ${basedir}/target/${project.artifactId}-${project.version}/WEB-INF/classes + + + src/main/resources + + env-entry.properties + + + + + + + copy-persistence-related-files-from-ejb-and-cxf-servlet-to-web-inf-classes + prepare-package + + copy-resources + + + ${basedir}/target/${project.artifactId}-${project.version}/WEB-INF/classes + + + ../jar/src/main/resources + true + + **/persistence.xml + **/orm.xml + + + + target/test-classes + + **/CXFServlet.class + + + + + + + copy-platform-specific-generated-web-xml-file-to-web-inf-classes + prepare-package + + copy-resources + + + ${basedir}/target/${project.artifactId}-${project.version}/WEB-INF + + + src/main/resources + true + + web.xml + + + + ../ejb/src/main/resources/META-INF + true + + **/ejb-jar.xml + + + + + + + + + + + + \ No newline at end of file diff --git a/war/src/main/java/be/dabla/AbstractInitialContextProvider.java b/war/src/main/java/be/dabla/AbstractInitialContextProvider.java new file mode 100644 index 0000000..4924acb --- /dev/null +++ b/war/src/main/java/be/dabla/AbstractInitialContextProvider.java @@ -0,0 +1,28 @@ +package be.dabla; + +import java.io.InputStream; +import java.io.Serializable; +import java.util.Properties; + +import javax.naming.InitialContext; + + +public abstract class AbstractInitialContextProvider implements Serializable { + protected static final InitialContext initialContext; + + static { + final Properties properties = new Properties(); + + try { + final InputStream input = Thread.currentThread().getContextClassLoader().getResourceAsStream("env-entry.properties"); + + if (input != null) { + properties.load(input); + } + + initialContext = new InitialContext(properties); + } catch(Exception e) { + throw new RuntimeException(e); + } + } +} \ No newline at end of file diff --git a/war/src/main/java/be/dabla/model/AbstractPaginationController.java b/war/src/main/java/be/dabla/model/AbstractPaginationController.java new file mode 100644 index 0000000..93092ea --- /dev/null +++ b/war/src/main/java/be/dabla/model/AbstractPaginationController.java @@ -0,0 +1,15 @@ +package be.dabla.model; + +import be.dabla.AbstractInitialContextProvider; + +public abstract class AbstractPaginationController extends AbstractInitialContextProvider { + final RepeatPaginator paginator; + + protected AbstractPaginationController(final RepeatPaginator paginator) { + this.paginator = paginator; + } + + public RepeatPaginator getPaginator() { + return paginator; + } +} \ No newline at end of file diff --git a/war/src/main/java/be/dabla/model/MessageController.java b/war/src/main/java/be/dabla/model/MessageController.java new file mode 100644 index 0000000..ffcafb9 --- /dev/null +++ b/war/src/main/java/be/dabla/model/MessageController.java @@ -0,0 +1,13 @@ +package be.dabla.model; + +import javax.naming.NamingException; + +import be.dabla.domain.MessageEJB; +import be.dabla.domain.MessageEJBRemote; +import be.dabla.model.Message; + +public class MessageController extends AbstractPaginationController { + public MessageController() throws NamingException { + super(new RepeatPaginator((MessageEJBRemote)initialContext.lookup(MessageEJB.class.getSimpleName()))); + } +} \ No newline at end of file diff --git a/war/src/main/java/be/dabla/model/RepeatPaginator.java b/war/src/main/java/be/dabla/model/RepeatPaginator.java new file mode 100644 index 0000000..e5d8eea --- /dev/null +++ b/war/src/main/java/be/dabla/model/RepeatPaginator.java @@ -0,0 +1,99 @@ +package be.dabla.model; + +import java.util.List; + +import be.dabla.domain.EJBLocal; + +public class RepeatPaginator { + private static final int DEFAULT_RECORDS_NUMBER = 50; + private static final int DEFAULT_PAGE_INDEX = 1; + + final EJBLocal ejb; + int records = DEFAULT_RECORDS_NUMBER; + int recordsTotal; + int pageIndex = DEFAULT_PAGE_INDEX; + int pages; + List model; + + public RepeatPaginator(final EJBLocal ejb) { + this.ejb = ejb; + + updateModel(); + } + + public void updateModel() { + this.recordsTotal = ejb.count().intValue(); + this.model = ejb.findAll(((getPageIndex() - 1) * getRecords()), getRecords()); + + if (records > 0) { + pages = records <= 0 ? 1 : recordsTotal / records; + + if (recordsTotal % records > 0) { + pages++; + } + + if (pages == 0) { + pages = 1; + } + } else { + records = 1; + pages = 1; + } + } + + private boolean isNext() { + return this.pageIndex < pages; + } + + public void next() { + if (isNext()) { + this.pageIndex++; + } + + updateModel(); + } + + private boolean isPrev() { + return this.pageIndex > 1; + } + + public void prev() { + if (isPrev()) { + this.pageIndex--; + } + + updateModel(); + } + + public void setRecords(int records) { + this.records = records; + } + + public int getRecords() { + return records; + } + + public int getRecordsTotal() { + return recordsTotal; + } + + public void setPageIndex(int pageIndex) { + this.pageIndex = pageIndex; + } + + public int getPageIndex() { + return pageIndex; + } + + public int getPages() { + return pages; + } + + public int getFirst() { + return (pageIndex * records) - records; + } + + public List getModel() { + return model; + } +} \ No newline at end of file diff --git a/war/src/main/java/be/dabla/service/AbstractAsynchronousWebService.java b/war/src/main/java/be/dabla/service/AbstractAsynchronousWebService.java new file mode 100644 index 0000000..b7db5cf --- /dev/null +++ b/war/src/main/java/be/dabla/service/AbstractAsynchronousWebService.java @@ -0,0 +1,46 @@ +package be.dabla.service; + +import java.util.Map; +import java.util.logging.Level; +import java.util.logging.Logger; + +import javax.xml.ws.WebServiceContext; + +import be.dabla.AbstractInitialContextProvider; +import be.dabla.service.handler.Address; +import be.dabla.service.util.MessageContextAddressingHelper; + +public abstract class AbstractAsynchronousWebService extends AbstractInitialContextProvider { + static final Logger logger = Logger.getLogger(AbstractAsynchronousWebService.class.getName()); + + protected abstract WebServiceContext getWebServiceContext(); + + protected Address getAddress(final T content) { + logger.log(Level.FINE, "content: ", content); + + if (content != null) { + try { + final MessageContextAddressingHelper helper = new MessageContextAddressingHelper(getWebServiceContext().getMessageContext()); + final String messageId = helper.getMessageId(); + final String replyTo = helper.getReplyTo(); + final String to = helper.getTo(); + final Map parameters = helper.getReferenceParameters(); + + logger.log(Level.FINE, "messageId: {0}", messageId); + logger.log(Level.FINE, "replyTo: {0}", replyTo); + logger.log(Level.FINE, "to: {0}", to); + logger.log(Level.FINE, "parameters: {0}", parameters); + + if ((messageId != null) && (replyTo != null) && (to != null)) { + + return new Address(content, messageId, to, replyTo, parameters); + } + } + catch(Exception e) { + throw new RuntimeException(e); + } + } + + return null; + } +} \ No newline at end of file diff --git a/war/src/main/java/be/dabla/service/impl/MessageServiceImpl.java b/war/src/main/java/be/dabla/service/impl/MessageServiceImpl.java new file mode 100644 index 0000000..e7de587 --- /dev/null +++ b/war/src/main/java/be/dabla/service/impl/MessageServiceImpl.java @@ -0,0 +1,54 @@ +package be.dabla.service.impl; + +import java.util.logging.Logger; + +import javax.annotation.Resource; +import javax.ejb.Stateless; +import javax.jws.WebService; +import javax.naming.NamingException; +import javax.xml.ws.WebServiceContext; +import javax.xml.ws.soap.Addressing; + +import be.dabla.domain.MessageMDBSender; +import be.dabla.domain.MessageMDBSenderRemote; +import be.dabla.model.Message; +import be.dabla.service.AbstractAsynchronousWebService; +import be.dabla.service.MessageService; + +@Stateless +@Addressing +@WebService( + serviceName = "MessageService", + portName = "MessageServicePort", + targetNamespace = "urn:service.dabla.be", + endpointInterface = "be.dabla.service.MessageService") +// http://biemond.blogspot.com/2011/02/building-asynchronous-web-service-with.html +public class MessageServiceImpl extends AbstractAsynchronousWebService implements MessageService { + private static final Logger logger = Logger.getLogger(MessageServiceImpl.class.getName()); + + @Resource + WebServiceContext context; + private final MessageMDBSenderRemote ejb; + + public MessageServiceImpl() throws NamingException { + ejb = (MessageMDBSenderRemote)initialContext.lookup(MessageMDBSender.class.getSimpleName()); + } + + @Override + public void create(final Message payload) { + try { + ejb.sendMessage(getAddress(payload)); + } + catch(Exception e) { + logger.severe(e.getMessage()); + } + } + + protected WebServiceContext getWebServiceContext() { + return context; + } + + @Override + public void callbackMessage(final Message payload) { + } +} \ No newline at end of file diff --git a/war/src/main/java/be/dabla/service/util/MessageContextAddressingHelper.java b/war/src/main/java/be/dabla/service/util/MessageContextAddressingHelper.java new file mode 100644 index 0000000..cebbb9f --- /dev/null +++ b/war/src/main/java/be/dabla/service/util/MessageContextAddressingHelper.java @@ -0,0 +1,146 @@ +package be.dabla.service.util; + +import java.io.IOException; +import java.io.StringReader; +import java.lang.reflect.InvocationTargetException; +import java.util.HashMap; +import java.util.Map; +import java.util.logging.Level; +import java.util.logging.Logger; + +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.ws.handler.MessageContext; + +import org.w3c.dom.Document; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; +import org.xml.sax.InputSource; +import org.xml.sax.SAXException; + +public class MessageContextAddressingHelper { + static final Logger logger = Logger.getLogger(MessageContextAddressingHelper.class.getName()); + + final DocumentBuilder builder; + final String messageId; + final String to; + final String replyTo; + final Map parameters; + + public MessageContextAddressingHelper(final MessageContext messageContext) throws ParserConfigurationException, SAXException, IOException, NoSuchMethodException, IllegalAccessException, InvocationTargetException { + this.builder = DocumentBuilderFactory.newInstance().newDocumentBuilder(); + + logger.log(Level.FINE, "messageContext: {0}", messageContext); + + if (messageContext.containsKey("com.sun.xml.ws.api.addressing.messageId")) { + messageId = (String)messageContext.get("com.sun.xml.ws.api.addressing.messageId"); + to = getAddress(messageContext.get("com.sun.xml.ws.api.addressing.to")); + replyTo = getAddress(messageContext.get("com.sun.xml.ws.addressing.WsaPropertyBag.ReplyToFromRequest")); + parameters = getReferenceParameters(messageContext.get("com.sun.xml.ws.addressing.WsaPropertyBag.ReplyToFromRequest")); + } + else { + if (messageContext.containsKey("javax.xml.ws.addressing.context.inbound")) { + messageId = getAttributedURITypeValue(messageContext.get("javax.xml.ws.addressing.context.inbound"), "getMessageID"); + to = getAttributedURITypeValue(messageContext.get("javax.xml.ws.addressing.context.inbound"), "getTo"); + replyTo = getEndpointReferenceTypeValue(messageContext.get("javax.xml.ws.addressing.context.inbound"), "getReplyTo"); + } + else { + messageId = null; + to = null; + replyTo = null; + } + + parameters = null; + } + } + + public String getMessageId() { + return messageId; + } + + public String getTo() { + return to; + } + + public String getReplyTo() { + return replyTo; + } + + public Map getReferenceParameters() { + return parameters; + } + + protected String getAddress(final Object value) throws SAXException, IOException { + final Node node = findNode(value, "Address"); + + if (node != null) { + return node.getTextContent(); + } + + return null; + } + + + protected Map getReferenceParameters(final Object value) throws SAXException, IOException { + final Node node = findNode(value, "ReferenceParameters"); + + if (node != null) { + final Map parameters = new HashMap(); + final NodeList children = node.getChildNodes(); + + for (int i = 0; i < children.getLength(); i++) { + final int index = children.item(i).getNodeName().indexOf(':'); + + parameters.put((index > -1 ? children.item(i).getNodeName().substring(index + 1) : children.item(i).getNodeName()), children.item(i).getTextContent()); + } + + return parameters; + } + + return null; + } + + protected Node findNode(final Object value, final String name) throws SAXException, IOException { + if (value != null) { + final NodeList list = toDocument(value.toString()).getChildNodes(); + + for (int i = 0; i < list.getLength(); i++) { + final NodeList children = list.item(i).getChildNodes(); + + for (int j = 0; j < children.getLength(); j++) { + if (children.item(j).getNodeName().endsWith(name)) { + return children.item(j); + } + } + } + } + + return null; + } + + + protected String getEndpointReferenceTypeValue(final Object instance, final String name) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException { + final Object object = instance.getClass().getDeclaredMethod(name, null).invoke(instance, null); + + if (object != null) { + return getAttributedURITypeValue(object, "getAddress"); + } + + return null; + } + + protected String getAttributedURITypeValue(final Object instance, final String name) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException { + final Object object = instance.getClass().getDeclaredMethod(name, null).invoke(instance, null); + + if (object != null) { + return (String)object.getClass().getDeclaredMethod("getValue", null).invoke(object, null); + } + + return null; + } + + protected Document toDocument(final String value) throws SAXException, IOException { + return builder.parse(new InputSource(new StringReader(value))); + } +} \ No newline at end of file diff --git a/war/src/main/resources/env-entry.properties b/war/src/main/resources/env-entry.properties new file mode 100644 index 0000000..c9c0fe4 --- /dev/null +++ b/war/src/main/resources/env-entry.properties @@ -0,0 +1,3 @@ +java.naming.factory.initial=org.apache.openejb.client.LocalInitialContextFactory +openejb.embedded.remotable=true +openejb.vendor.config=NONE \ No newline at end of file diff --git a/war/src/main/resources/web.xml b/war/src/main/resources/web.xml new file mode 100644 index 0000000..67690e6 --- /dev/null +++ b/war/src/main/resources/web.xml @@ -0,0 +1,34 @@ + + + + + javax.faces.PROJECT_STAGE + ${stage} + + + + + index.xhtml + + + ${servlet} + + + + Faces Servlet + javax.faces.webapp.FacesServlet + 2 + + + ${servlet-mapping} + + + + Faces Servlet + *.xhtml + + + ${persistence} + \ No newline at end of file diff --git a/war/src/main/resources/wsdl/MessageService.wsdl b/war/src/main/resources/wsdl/MessageService.wsdl new file mode 100644 index 0000000..df4986d --- /dev/null +++ b/war/src/main/resources/wsdl/MessageService.wsdl @@ -0,0 +1,48 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/war/src/main/resources/wsdl/MessageService_schema1.xsd b/war/src/main/resources/wsdl/MessageService_schema1.xsd new file mode 100644 index 0000000..4ae2917 --- /dev/null +++ b/war/src/main/resources/wsdl/MessageService_schema1.xsd @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/war/src/main/resources/wsdl/MessageService_schema2.xsd b/war/src/main/resources/wsdl/MessageService_schema2.xsd new file mode 100644 index 0000000..967db77 --- /dev/null +++ b/war/src/main/resources/wsdl/MessageService_schema2.xsd @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/war/src/main/webapp/WEB-INF/faces-config.xml b/war/src/main/webapp/WEB-INF/faces-config.xml new file mode 100644 index 0000000..2a3b2b4 --- /dev/null +++ b/war/src/main/webapp/WEB-INF/faces-config.xml @@ -0,0 +1,17 @@ + + + + + en + + + + messageController + be.dabla.model.MessageController + request + + \ No newline at end of file diff --git a/war/src/main/webapp/index.xhtml b/war/src/main/webapp/index.xhtml new file mode 100644 index 0000000..0c113a7 --- /dev/null +++ b/war/src/main/webapp/index.xhtml @@ -0,0 +1,40 @@ + + + Messages + + +

Messages

+
+ + + + + + + + + + + + + + + + +
IdDescriptionDate
${item.id}${item.description} + + + +
+ + ${messageController.paginator.pageIndex} / ${messageController.paginator.pages} + + + + + \ No newline at end of file diff --git a/war/src/main/webapp/resources/css/reset.css b/war/src/main/webapp/resources/css/reset.css new file mode 100644 index 0000000..af94440 --- /dev/null +++ b/war/src/main/webapp/resources/css/reset.css @@ -0,0 +1,48 @@ +/* http://meyerweb.com/eric/tools/css/reset/ + v2.0 | 20110126 + License: none (public domain) +*/ + +html, body, div, span, applet, object, iframe, +h1, h2, h3, h4, h5, h6, p, blockquote, pre, +a, abbr, acronym, address, big, cite, code, +del, dfn, em, img, ins, kbd, q, s, samp, +small, strike, strong, sub, sup, tt, var, +b, u, i, center, +dl, dt, dd, ol, ul, li, +fieldset, form, label, legend, +table, caption, tbody, tfoot, thead, tr, th, td, +article, aside, canvas, details, embed, +figure, figcaption, footer, header, hgroup, +menu, nav, output, ruby, section, summary, +time, mark, audio, video { + margin: 0; + padding: 0; + border: 0; + font-size: 100%; + font: inherit; + vertical-align: baseline; +} +/* HTML5 display-role reset for older browsers */ +article, aside, details, figcaption, figure, +footer, header, hgroup, menu, nav, section { + display: block; +} +body { + line-height: 1; +} +ol, ul { + list-style: none; +} +blockquote, q { + quotes: none; +} +blockquote:before, blockquote:after, +q:before, q:after { + content: ''; + content: none; +} +table { + border-collapse: collapse; + border-spacing: 0; +} \ No newline at end of file diff --git a/war/src/main/webapp/templates/layout.xhtml b/war/src/main/webapp/templates/layout.xhtml new file mode 100644 index 0000000..1cf5009 --- /dev/null +++ b/war/src/main/webapp/templates/layout.xhtml @@ -0,0 +1,19 @@ + + + + + + + <ui:insert name="title" /> + + + + + + + \ No newline at end of file diff --git a/war/src/test/java/be/dabla/model/RequestControllerTest.java b/war/src/test/java/be/dabla/model/RequestControllerTest.java new file mode 100644 index 0000000..a86491c --- /dev/null +++ b/war/src/test/java/be/dabla/model/RequestControllerTest.java @@ -0,0 +1,23 @@ +package be.dabla.model; + +import static org.junit.Assert.assertNotNull; + +import javax.naming.NamingException; + +import org.apache.openejb.OpenEJBTestCase; +import org.apache.openejb.api.LocalClient; +import org.junit.Test; + +import be.dabla.model.Message; + +@LocalClient +public class RequestControllerTest extends OpenEJBTestCase { + @Test + public void testPaginator() throws NamingException { + final MessageController controller = new MessageController(); + final RepeatPaginator paginator = controller.getPaginator(); + assertNotNull(paginator); + paginator.prev(); + paginator.next(); + } +} \ No newline at end of file diff --git a/war/src/test/java/be/dabla/service/MessageServiceTest.java b/war/src/test/java/be/dabla/service/MessageServiceTest.java new file mode 100644 index 0000000..d3873a0 --- /dev/null +++ b/war/src/test/java/be/dabla/service/MessageServiceTest.java @@ -0,0 +1,29 @@ +package be.dabla.service; + +import javax.xml.ws.WebServiceRef; + +import org.apache.openejb.api.LocalClient; +import org.junit.Test; + +import be.dabla.model.Message; + +@LocalClient +public class MessageServiceTest extends WebServiceTestCase { + @WebServiceRef(wsdlLocation = "http://127.0.0.1:4204/MessageServiceImpl?wsdl") + private MessageService port; + + public MessageService getPort() { + return port; + } + + //http://svn.apache.org/repos/asf/openejb/tags/openejb-3.1.1/examples/simple-webservice/src/main/java/org/superbiz/calculator/CalculatorImpl.java + @Test + public void testCreate() throws Exception { + getPort().create(new Message("Hello David")); + } + + @Test + public void testCallbackMessage() { + getPort().callbackMessage(new Message("Hello David")); + } +} \ No newline at end of file diff --git a/war/src/test/java/be/dabla/service/WebServiceTestCase.java b/war/src/test/java/be/dabla/service/WebServiceTestCase.java new file mode 100644 index 0000000..6202904 --- /dev/null +++ b/war/src/test/java/be/dabla/service/WebServiceTestCase.java @@ -0,0 +1,63 @@ +package be.dabla.service; + +import static org.apache.cxf.ws.addressing.JAXWSAConstants.CLIENT_ADDRESSING_PROPERTIES; + +import javax.xml.ws.BindingProvider; + +import org.apache.cxf.binding.soap.saaj.SAAJInInterceptor; +import org.apache.cxf.binding.soap.saaj.SAAJOutInterceptor; +import org.apache.cxf.endpoint.Client; +import org.apache.cxf.endpoint.Endpoint; +import org.apache.cxf.frontend.ClientProxy; +import org.apache.cxf.jaxws.support.JaxWsEndpointImpl; +import org.apache.cxf.ws.addressing.AddressingProperties; +import org.apache.cxf.ws.addressing.AddressingPropertiesImpl; +import org.apache.cxf.ws.addressing.WSAddressingFeature; +import org.apache.openejb.OpenEJBTestCase; +import org.junit.After; +import org.junit.Before; + + +public abstract class WebServiceTestCase extends OpenEJBTestCase { + public abstract T getPort(); + + /*@Before + public void setUp() throws Exception { + super.setUp(); + + final Client client = ClientProxy.getClient(getPort()); + final Endpoint endpoint = client.getEndpoint(); + endpoint.getInInterceptors().add(new SAAJInInterceptor()); + endpoint.getOutInterceptors().add(new SAAJOutInterceptor()); + + enableWSAddressing(); + } + + @After + public void tearDown() throws Exception { + super.tearDown(); + + final Endpoint endpoint = ClientProxy.getClient(getPort()).getEndpoint(); + endpoint.getInInterceptors().clear(); + endpoint.getOutInterceptors().clear(); + + disableWSAddressing(); + } + + protected void enableWSAddressing() { + final Client client = ClientProxy.getClient(getPort()); + final Endpoint endpoint = client.getEndpoint(); + final WSAddressingFeature addressingFeature = new WSAddressingFeature(); + addressingFeature.setAddressingRequired(true); + final AddressingProperties maps = new AddressingPropertiesImpl(); + maps.setReplyTo(endpoint.getEndpointInfo().getTarget()); + ((BindingProvider)getPort()).getRequestContext().put(CLIENT_ADDRESSING_PROPERTIES, maps); + ((JaxWsEndpointImpl)client.getEndpoint()).getFeatures().add(addressingFeature); + } + + protected void disableWSAddressing() { + final Client client = ClientProxy.getClient(getPort()); + ((BindingProvider)getPort()).getRequestContext().clear(); + ((JaxWsEndpointImpl)client.getEndpoint()).getFeatures().clear(); + }*/ +} \ No newline at end of file diff --git a/war/src/test/java/be/dabla/service/util/MessageContextAddressingHelperTest.java b/war/src/test/java/be/dabla/service/util/MessageContextAddressingHelperTest.java new file mode 100644 index 0000000..18e7a05 --- /dev/null +++ b/war/src/test/java/be/dabla/service/util/MessageContextAddressingHelperTest.java @@ -0,0 +1,19 @@ +package be.dabla.service.util; + +import static org.junit.Assert.assertNotNull; + +import org.junit.Test; + +import be.dabla.service.MockMessageContext; +import be.dabla.service.util.MessageContextAddressingHelper; + +public class MessageContextAddressingHelperTest { + @Test + public void testHelper() throws Exception { + final MessageContextAddressingHelper helper = new MessageContextAddressingHelper(new MockMessageContext()); + + assertNotNull(helper.getMessageId()); + assertNotNull(helper.getReplyTo()); + assertNotNull(helper.getTo()); + } +} \ No newline at end of file diff --git a/war/src/test/java/be/dabla/servlet/CXFServlet.java b/war/src/test/java/be/dabla/servlet/CXFServlet.java new file mode 100644 index 0000000..a8e2998 --- /dev/null +++ b/war/src/test/java/be/dabla/servlet/CXFServlet.java @@ -0,0 +1,114 @@ +package be.dabla.servlet; + +import java.io.File; +import java.io.IOException; +import java.net.URISyntaxException; +import java.net.URL; +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.List; +import java.util.logging.Level; +import java.util.logging.Logger; + +import javax.jws.WebService; +import javax.servlet.ServletConfig; +import javax.servlet.ServletException; +import javax.xml.ws.Endpoint; + +import org.apache.cxf.BusFactory; +import org.apache.cxf.frontend.ServerFactoryBean; +import org.apache.cxf.transport.servlet.CXFNonSpringServlet; + +public class CXFServlet extends CXFNonSpringServlet { + private static final Logger logger = Logger.getLogger(CXFServlet.class.getName()); + + private String packageName; + + public String getPackageName() { + return packageName; + } + + public void setPackageName(String packageName) { + this.packageName = packageName; + } + + public void init() + throws ServletException + { + setPackageName(getServletConfig().getInitParameter("package")); + } + + @Override + public void loadBus(final ServletConfig servletConfig) throws ServletException { + super.loadBus(servletConfig); + + BusFactory.setDefaultBus(bus); + + try { + logger.log(Level.FINE, "packageName: {0}", getPackageName()); + + for (final Class implementation : getClasses(getPackageName())) { + final WebService annotation = (WebService)implementation.getAnnotation(WebService.class); + + logger.log(Level.FINE, "annotation: {0}", annotation); + + // only accept classes which are annotated with the WebService annotation + if (annotation != null) { + logger.log(Level.INFO, "Publishing endpoint ''{0}'' for class ''{1}''.", new Object[]{annotation.serviceName(),implementation.getName()}); + + Endpoint.publish("/" + annotation.serviceName(), implementation.newInstance()); + } + } + } catch(Exception e) { + throw new ServletException(e); + } + } + + /** + * Scans all classes accessible from the context class loader which belong to the given package and subpackages. + * + * @param packageName The base package + * @return The classes + * @throws ClassNotFoundException + * @throws IOException + * @throws URISyntaxException + */ + private static Class[] getClasses(final String packageName) + throws ClassNotFoundException, IOException, URISyntaxException { + final Enumeration resources = Thread.currentThread().getContextClassLoader().getResources(packageName.replace('.', '/')); + final List dirs = new ArrayList(); + while (resources.hasMoreElements()) { + dirs.add(new File(resources.nextElement().toURI())); + } + final ArrayList classes = new ArrayList(); + for (final File directory : dirs) { + classes.addAll(findClasses(directory, packageName)); + } + return classes.toArray(new Class[classes.size()]); + } + + /** + * Recursive method used to find all classes in a given directory and subdirs. + * + * @param directory The base directory + * @param packageName The package name for classes found inside the base directory + * @return The classes + * @throws ClassNotFoundException + */ + private static List findClasses(File directory, String packageName) throws ClassNotFoundException { + final List classes = new ArrayList(); + if (!directory.exists()) { + return classes; + } + final File[] files = directory.listFiles(); + for (File file : files) { + if (file.isDirectory()) { + assert !file.getName().contains("."); + classes.addAll(findClasses(file, packageName + '.' + file.getName())); + } else if (file.getName().endsWith(".class")) { + classes.add(Class.forName(packageName + '.' + file.getName().substring(0, file.getName().length() - 6))); + } + } + return classes; + } +} \ No newline at end of file diff --git a/war/src/test/java/org/apache/cxf/jaxws/support/JaxWsServiceFactoryBean.java b/war/src/test/java/org/apache/cxf/jaxws/support/JaxWsServiceFactoryBean.java new file mode 100644 index 0000000..684e257 --- /dev/null +++ b/war/src/test/java/org/apache/cxf/jaxws/support/JaxWsServiceFactoryBean.java @@ -0,0 +1,654 @@ +/** + * 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.jaxws.support; + +import java.lang.reflect.Method; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.logging.Level; +import java.util.logging.Logger; + +import javax.jws.WebMethod; +import javax.wsdl.Operation; +import javax.xml.bind.annotation.XmlNsForm; +import javax.xml.bind.annotation.XmlSchema; +import javax.xml.bind.annotation.XmlSeeAlso; +import javax.xml.namespace.QName; +import javax.xml.ws.Action; +import javax.xml.ws.AsyncHandler; +import javax.xml.ws.BindingType; +import javax.xml.ws.FaultAction; +import javax.xml.ws.Provider; +import javax.xml.ws.Service; +import javax.xml.ws.WebFault; +import javax.xml.ws.WebServiceFeature; +import javax.xml.ws.soap.Addressing; +import javax.xml.ws.soap.AddressingFeature; +import javax.xml.ws.soap.MTOM; +import javax.xml.ws.soap.MTOMFeature; +import javax.xml.ws.soap.SOAPBinding; + +import org.apache.cxf.common.classloader.ClassLoaderUtils; +import org.apache.cxf.common.i18n.Message; +import org.apache.cxf.common.logging.LogUtils; +import org.apache.cxf.common.util.PackageUtils; +import org.apache.cxf.common.util.StringUtils; +import org.apache.cxf.common.util.XMLSchemaQNames; +import org.apache.cxf.databinding.DataBinding; +import org.apache.cxf.databinding.source.SourceDataBinding; +import org.apache.cxf.endpoint.Endpoint; +import org.apache.cxf.endpoint.EndpointException; +import org.apache.cxf.helpers.CastUtils; +import org.apache.cxf.jaxws.JAXWSMethodDispatcher; +import org.apache.cxf.jaxws.JAXWSProviderMethodDispatcher; +import org.apache.cxf.jaxws.WrapperClassGenerator; +import org.apache.cxf.jaxws.interceptors.WebFaultOutInterceptor; +import org.apache.cxf.service.factory.AbstractServiceConfiguration; +import org.apache.cxf.service.factory.ReflectionServiceFactoryBean; +import org.apache.cxf.service.factory.ServiceConstructionException; +import org.apache.cxf.service.model.BindingInfo; +import org.apache.cxf.service.model.BindingOperationInfo; +import org.apache.cxf.service.model.EndpointInfo; +import org.apache.cxf.service.model.FaultInfo; +import org.apache.cxf.service.model.InterfaceInfo; +import org.apache.cxf.service.model.MessageInfo; +import org.apache.cxf.service.model.MessagePartInfo; +import org.apache.cxf.service.model.OperationInfo; +import org.apache.cxf.service.model.ServiceInfo; +import org.apache.cxf.ws.addressing.JAXWSAConstants; +import org.apache.cxf.wsdl11.WSDLServiceBuilder; + +/** + * Constructs a service model from JAX-WS service endpoint classes. Works + * with both @@WebServiceProvider and @@WebService annotated classes. + * + * @see org.apache.cxf.jaxws.JaxWsServerFactoryBean + */ +// http://community.jboss.org/message/608047 +public class JaxWsServiceFactoryBean extends ReflectionServiceFactoryBean { + // used to tag property on service. + public static final String WS_FEATURES = "JAXWS-WS-FEATURES"; + private static final Logger LOG = LogUtils.getLogger(JaxWsServiceFactoryBean.class); + + private AbstractServiceConfiguration jaxWsConfiguration; + + private JaxWsImplementorInfo implInfo; + + private List setWsFeatures; + private List wsFeatures; + + private boolean wrapperBeanGenerated; + private Set> wrapperClasses; + + + public JaxWsServiceFactoryBean() { + getIgnoredClasses().add(Service.class.getName()); + + //the JAXWS-RI doesn't qualify the schemas for the wrapper types + //and thus won't work if we do. + setQualifyWrapperSchema(false); + initSchemaLocations(); + } + + public JaxWsServiceFactoryBean(JaxWsImplementorInfo implInfo) { + this(); + this.implInfo = implInfo; + initConfiguration(implInfo); + this.serviceClass = implInfo.getEndpointClass(); + this.serviceType = implInfo.getSEIType(); + loadWSFeatureAnnotation(implInfo.getSEIClass(), implInfo.getImplementorClass()); + } + + @Override + public void reset() { + super.reset(); + wrapperBeanGenerated = false; + wrapperClasses = null; + } + + private void initSchemaLocations() { + this.schemaLocationMapping.put(JAXWSAConstants.NS_WSA, + JAXWSAConstants.WSA_XSD); + } + + private void loadWSFeatureAnnotation(Class serviceClass, Class implementorClass) { + List features = new ArrayList(); + MTOM mtom = implInfo.getImplementorClass().getAnnotation(MTOM.class); + if (mtom == null && serviceClass != null) { + mtom = serviceClass.getAnnotation(MTOM.class); + } + if (mtom != null) { + features.add(new MTOMFeature(mtom.enabled(), mtom.threshold())); + } else { + //deprecated way to set mtom + BindingType bt = implInfo.getImplementorClass().getAnnotation(BindingType.class); + if (bt != null + && (SOAPBinding.SOAP11HTTP_MTOM_BINDING.equals(bt.value()) + || SOAPBinding.SOAP12HTTP_MTOM_BINDING.equals(bt.value()))) { + features.add(new MTOMFeature(true)); + } + } + + + Addressing addressing = null; + if (implementorClass != null) { + addressing = implementorClass.getAnnotation(Addressing.class); + } + + if (addressing == null && serviceClass != null) { + addressing = serviceClass.getAnnotation(Addressing.class); + } + + if (addressing != null) { + features.add(new AddressingFeature(addressing.enabled(), addressing.required())); + } + + if (features.size() > 0) { + wsFeatures = features; + if (setWsFeatures != null) { + wsFeatures.addAll(setWsFeatures); + } + } else { + wsFeatures = setWsFeatures; + } + } + + @Override + public org.apache.cxf.service.Service create() { + org.apache.cxf.service.Service s = super.create(); + + s.put(ENDPOINT_CLASS, implInfo.getEndpointClass()); + + return s; + } + + + @Override + public void setServiceClass(Class serviceClass) { + if (serviceClass == null) { + Message message = new Message("SERVICECLASS_MUST_BE_SET", LOG); + throw new ServiceConstructionException(message); + } + setJaxWsImplementorInfo(new JaxWsImplementorInfo(serviceClass)); + super.setServiceClass(getJaxWsImplementorInfo().getEndpointClass()); + super.setServiceType(getJaxWsImplementorInfo().getSEIType()); + } + @Override + protected void checkServiceClassAnnotations(Class sc) { + //no need to check + } + + @Override + protected void initializeFaultInterceptors() { + getService().getOutFaultInterceptors().add(new WebFaultOutInterceptor()); + } + + @Override + public Endpoint createEndpoint(EndpointInfo ei) throws EndpointException { + return new JaxWsEndpointImpl(getBus(), getService(), ei, implInfo, wsFeatures, + this.getFeatures(), this.isFromWsdl()); + } + + @Override + protected void initializeWSDLOperation(InterfaceInfo intf, OperationInfo o, Method method) { + method = ((JaxWsServiceConfiguration)jaxWsConfiguration).getDeclaredMethod(method); + o.setProperty(Method.class.getName(), method); + o.setProperty(METHOD, method); + initializeWrapping(o, method); + + // rpc out-message-part-info class mapping + Operation op = (Operation)o.getProperty(WSDLServiceBuilder.WSDL_OPERATION); + + initializeClassInfo(o, method, op == null ? null + : CastUtils.cast(op.getParameterOrdering(), String.class)); + + bindOperation(o, method); + } + + protected void bindOperation(OperationInfo op, Method method) { + + try { + // Find the Async method which returns a Response + Method responseMethod = method.getDeclaringClass().getDeclaredMethod(method.getName() + "Async", + method.getParameterTypes()); + + // Find the Async method whic has a Future & AsyncResultHandler + List> asyncHandlerParams = Arrays.asList(method.getParameterTypes()); + //copy it to may it non-readonly + asyncHandlerParams = new ArrayList>(asyncHandlerParams); + asyncHandlerParams.add(AsyncHandler.class); + Method futureMethod = method.getDeclaringClass() + .getDeclaredMethod(method.getName() + "Async", + asyncHandlerParams.toArray(new Class[asyncHandlerParams.size()])); + + getMethodDispatcher().bind(op, method, responseMethod, futureMethod); + + } catch (SecurityException e) { + throw new ServiceConstructionException(e); + } catch (NoSuchMethodException e) { + getMethodDispatcher().bind(op, method); + } + } + + @Override + protected void initializeWSDLOperations() { + if (implInfo.isWebServiceProvider()) { + initializeWSDLOperationsForProvider(); + } else { + super.initializeWSDLOperations(); + } + } + + protected void initializeWSDLOperationsForProvider() { + Class c = getProviderParameterType(getServiceClass()); + if (c == null) { + throw new ServiceConstructionException(new Message("INVALID_PROVIDER_EXC", LOG)); + } + + if (getEndpointInfo() == null + && isFromWsdl()) { + //most likely, they specified a WSDL, but for some reason + //did not give a valid ServiceName/PortName. For provider, + //we'll allow this since everything is bound directly to + //the invoke method, however, this CAN cause other problems + //such as addresses in the wsdl not getting updated and such + //so we'll WARN about it..... + List enames = new ArrayList(); + for (ServiceInfo si : getService().getServiceInfos()) { + for (EndpointInfo ep : si.getEndpoints()) { + enames.add(ep.getName()); + } + } + LOG.log(Level.WARNING, "COULD_NOT_FIND_ENDPOINT", + new Object[] {getEndpointName(), enames}); + } + + try { + Method invoke = getServiceClass().getMethod("invoke", c); + QName catchAll = new QName("http://cxf.apache.org/jaxws/provider", "invoke"); + + // Bind every operation to the invoke method. + for (ServiceInfo si : getService().getServiceInfos()) { + si.setProperty("soap.force.doclit.bare", Boolean.TRUE); + for (BindingInfo bind : si.getBindings()) { + for (BindingOperationInfo bop : bind.getOperations()) { + OperationInfo o = bop.getOperationInfo(); + if (o.getInput() != null) { + if (o.getInput().getMessageParts().isEmpty()) { + MessagePartInfo inf = o.getInput().addMessagePart(o.getName()); + inf.setConcreteName(o.getName()); + bop.getInput().setMessageParts(o.getInput().getMessageParts()); + } + for (MessagePartInfo inf : o.getInput().getMessageParts()) { + inf.setTypeClass(c); + break; + } + } + if (o.getOutput() != null) { + if (o.getOutput().getMessageParts().isEmpty()) { + MessagePartInfo inf = o.getOutput().addMessagePart(o.getName()); + inf.setConcreteName(new QName(o.getName().getNamespaceURI(), + o.getName().getLocalPart() + "Response")); + bop.getOutput().setMessageParts(o.getOutput().getMessageParts()); + } + for (MessagePartInfo inf : o.getOutput().getMessageParts()) { + inf.setTypeClass(c); + break; + } + } + getMethodDispatcher().bind(o, invoke); + } + BindingOperationInfo bop = bind.getOperation(catchAll); + if (bop == null) { + OperationInfo op = bind.getInterface().getOperation(catchAll); + if (op == null) { + op = bind.getInterface().addOperation(catchAll); + String name = catchAll.getLocalPart(); + MessageInfo mInfo = op.createMessage(new QName(catchAll.getNamespaceURI(), + name + "Request"), + MessageInfo.Type.INPUT); + op.setInput(catchAll.getLocalPart() + "Request", mInfo); + MessagePartInfo mpi = mInfo.addMessagePart("parameters"); + mpi.setElement(true); + mpi.setTypeClass(c); + mpi.setTypeQName(XMLSchemaQNames.XSD_ANY); + + mInfo = op.createMessage(new QName(catchAll.getNamespaceURI(), + name + "Response"), + MessageInfo.Type.OUTPUT); + op.setOutput(name + "Response", mInfo); + mpi = mInfo.addMessagePart("parameters"); + mpi.setElement(true); + mpi.setTypeClass(c); + mpi.setTypeQName(XMLSchemaQNames.XSD_ANY); + + BindingOperationInfo bo = new BindingOperationInfo(bind, op); + op.setProperty("operation.is.synthetic", Boolean.TRUE); + bo.setProperty("operation.is.synthetic", Boolean.TRUE); + bind.addOperation(bo); + } + } + } + } + } catch (SecurityException e) { + throw new ServiceConstructionException(e); + } catch (NoSuchMethodException e) { + throw new ServiceConstructionException(e); + } + + + } + + protected Class getProviderParameterType(Class cls) { + if (cls == null) { + return null; + } + Type[] genericInterfaces = cls.getGenericInterfaces(); + for (Type type : genericInterfaces) { + if (type instanceof ParameterizedType) { + Class rawCls = (Class)((ParameterizedType)type).getRawType(); + if (Provider.class == rawCls) { + return (Class)((ParameterizedType)type).getActualTypeArguments()[0]; + } + } else if (type instanceof Class && Provider.class.isAssignableFrom((Class)type)) { + return getProviderParameterType((Class)type); + } + } + return getProviderParameterType(cls.getSuperclass()); + } + + void initializeWrapping(OperationInfo o, Method selected) { + Class responseWrapper = getResponseWrapper(selected); + if ((responseWrapper != null) && (o.getOutput() != null)) { + o.getOutput().getMessageParts().get(0).setTypeClass(responseWrapper); + } + if ((getResponseWrapperClassName(selected) != null) && (o.getOutput() != null)) { + o.getOutput().getMessageParts().get(0).setProperty("RESPONSE.WRAPPER.CLASSNAME", + getResponseWrapperClassName(selected)); + } + Class requestWrapper = getRequestWrapper(selected); + if (requestWrapper != null) { + o.getInput().getMessageParts().get(0).setTypeClass(requestWrapper); + } + if (getRequestWrapperClassName(selected) != null) { + o.getInput().getMessageParts().get(0).setProperty("REQUEST.WRAPPER.CLASSNAME", + getRequestWrapperClassName(selected)); + } + } + + + @Override + protected Class getBeanClass(Class exClass) { + try { + if (java.rmi.ServerException.class.isAssignableFrom(exClass) + || java.rmi.RemoteException.class.isAssignableFrom(exClass) + || "javax.xml.ws".equals(PackageUtils.getPackageName(exClass))) { + return null; + } + + Method getFaultInfo = exClass.getMethod("getFaultInfo", new Class[0]); + + return getFaultInfo.getReturnType(); + } catch (SecurityException e) { + throw new ServiceConstructionException(e); + } catch (NoSuchMethodException e) { + //ignore for now + } + WebFault fault = exClass.getAnnotation(WebFault.class); + if (fault != null && !StringUtils.isEmpty(fault.faultBean())) { + try { + return ClassLoaderUtils.loadClass(fault.faultBean(), + exClass); + } catch (ClassNotFoundException e1) { + //ignore + } + } + + return super.getBeanClass(exClass); + } + + public void setJaxWsConfiguration(JaxWsServiceConfiguration jaxWsConfiguration) { + this.jaxWsConfiguration = jaxWsConfiguration; + } + + public JaxWsImplementorInfo getJaxWsImplementorInfo() { + return implInfo; + } + + public void setJaxWsImplementorInfo(JaxWsImplementorInfo jaxWsImplementorInfo) { + this.implInfo = jaxWsImplementorInfo; + + initConfiguration(jaxWsImplementorInfo); + } + + protected final void initConfiguration(JaxWsImplementorInfo ii) { + if (ii.isWebServiceProvider()) { + jaxWsConfiguration = new WebServiceProviderConfiguration(); + jaxWsConfiguration.setServiceFactory(this); + getServiceConfigurations().add(0, jaxWsConfiguration); + setWrapped(false); + setDataBinding(new SourceDataBinding()); + setMethodDispatcher(new JAXWSProviderMethodDispatcher(implInfo)); + } else { + jaxWsConfiguration = new JaxWsServiceConfiguration(); + jaxWsConfiguration.setServiceFactory(this); + getServiceConfigurations().add(0, jaxWsConfiguration); + + Class seiClass = ii.getEndpointClass(); + if (seiClass != null && seiClass.getPackage() != null) { + XmlSchema schema = seiClass.getPackage().getAnnotation(XmlSchema.class); + if (schema != null && XmlNsForm.QUALIFIED.equals(schema.elementFormDefault())) { + setQualifyWrapperSchema(true); + } + } + setMethodDispatcher(new JAXWSMethodDispatcher(implInfo)); + } + loadWSFeatureAnnotation(ii.getSEIClass(), ii.getImplementorClass()); + } + + public List getWsFeatures() { + return setWsFeatures; + } + + public void setWsFeatures(List swsFeatures) { + this.setWsFeatures = swsFeatures; + if (wsFeatures == null) { + wsFeatures = setWsFeatures; + } + } + + private FaultInfo getFaultInfo(final OperationInfo operation, final Class expClass) { + for (FaultInfo fault : operation.getFaults()) { + if (fault.getProperty(Class.class.getName()) == expClass + || fault.getProperty(Class.class.getName()) == expClass) { + return fault; + } + } + return null; + } + private void buildWSAActions(OperationInfo operation, Method method) { + //nothing + if (method == null) { + return; + } + + Action action = method.getAnnotation(Action.class); + Addressing addressing = method.getDeclaringClass().getAnnotation(Addressing.class); + if (action == null && addressing == null) { + return; + } + WebMethod wm = method.getAnnotation(WebMethod.class); + String inputAction = ""; + if (action != null) { + inputAction = action.input(); + } + if (wm != null && StringUtils.isEmpty(inputAction)) { + inputAction = wm.action(); + } + if (StringUtils.isEmpty(inputAction)) { + inputAction = computeAction(operation, "Request"); + } + + if (action == null && addressing != null) { + operation.getInput().addExtensionAttribute(JAXWSAConstants.WSAM_ACTION_QNAME, + inputAction); + operation.getInput().addExtensionAttribute(JAXWSAConstants.WSAW_ACTION_QNAME, + inputAction); + + if (operation.getOutput() != null) { + operation.getOutput().addExtensionAttribute(JAXWSAConstants.WSAM_ACTION_QNAME, + computeAction(operation, "Response")); + operation.getOutput().addExtensionAttribute(JAXWSAConstants.WSAW_ACTION_QNAME, + computeAction(operation, "Response")); + } + + } else { + MessageInfo input = operation.getInput(); + input.addExtensionAttribute(JAXWSAConstants.WSAM_ACTION_QNAME, inputAction); + if (!StringUtils.isEmpty(action.input())) { + input.addExtensionAttribute(JAXWSAConstants.WSAW_ACTION_QNAME, inputAction); + } + + MessageInfo output = operation.getOutput(); + if (output != null && !StringUtils.isEmpty(action.output())) { + output.addExtensionAttribute(JAXWSAConstants.WSAW_ACTION_QNAME, action.output()); + output.addExtensionAttribute(JAXWSAConstants.WSAM_ACTION_QNAME, action.output()); + } else if (output != null) { + output.addExtensionAttribute(JAXWSAConstants.WSAM_ACTION_QNAME, computeAction(operation, + "Response")); + } + + FaultAction[] faultActions = action.fault(); + if (faultActions != null && faultActions.length > 0 && operation.getFaults() != null) { + for (FaultAction faultAction : faultActions) { + FaultInfo faultInfo = getFaultInfo(operation, faultAction.className()); + if (!StringUtils.isEmpty(faultAction.value())) { + faultInfo.addExtensionAttribute(JAXWSAConstants.WSAW_ACTION_QNAME, faultAction + .value()); + faultInfo.addExtensionAttribute(JAXWSAConstants.WSAM_ACTION_QNAME, faultAction + .value()); + } + if (operation.isUnwrappedCapable()) { + faultInfo = getFaultInfo(operation.getUnwrappedOperation(), faultAction.className()); + if (!StringUtils.isEmpty(faultAction.value())) { + faultInfo.addExtensionAttribute(JAXWSAConstants.WSAW_ACTION_QNAME, faultAction + .value()); + faultInfo.addExtensionAttribute(JAXWSAConstants.WSAM_ACTION_QNAME, faultAction + .value()); + } + } + } + } + } + for (FaultInfo fi : operation.getFaults()) { + if (fi.getExtensionAttribute(JAXWSAConstants.WSAM_ACTION_QNAME) == null) { + String f = "/Fault/" + fi.getName().getLocalPart(); + fi.addExtensionAttribute(JAXWSAConstants.WSAM_ACTION_QNAME, + computeAction(operation, f)); + if (operation.isUnwrappedCapable()) { + fi = operation.getUnwrappedOperation().getFault(fi.getName()); + fi.addExtensionAttribute(JAXWSAConstants.WSAM_ACTION_QNAME, + computeAction(operation, f)); + } + } + } + } + + private String computeAction(OperationInfo op, String postFix) { + StringBuilder s = new StringBuilder(op.getName().getNamespaceURI()); + if (s.charAt(s.length() - 1) != '/') { + s.append('/'); + } + s.append(op.getInterface().getName().getLocalPart()) + .append('/').append(op.getName().getLocalPart()).append(postFix); + return s.toString(); + } + + @Override + protected OperationInfo createOperation(ServiceInfo serviceInfo, InterfaceInfo intf, Method m) { + OperationInfo op = super.createOperation(serviceInfo, intf, m); + if (op.getUnwrappedOperation() != null) { + op = op.getUnwrappedOperation(); + } + buildWSAActions(op, m); + return op; + } + + @Override + protected Set> getExtraClass() { + Set> classes = new HashSet>(); + if (!wrapperBeanGenerated) { + wrapperClasses = generatedWrapperBeanClass(); + } + if (wrapperClasses != null) { + classes.addAll(wrapperClasses); + } + + XmlSeeAlso xmlSeeAlsoAnno = getServiceClass().getAnnotation(XmlSeeAlso.class); + + if (xmlSeeAlsoAnno != null && xmlSeeAlsoAnno.value() != null) { + for (int i = 0; i < xmlSeeAlsoAnno.value().length; i++) { + Class value = xmlSeeAlsoAnno.value()[i]; + if (value == null) { + LOG.log(Level.WARNING, "XMLSEEALSO_NULL_CLASS", + new Object[] {getServiceClass().getName(), i}); + } else { + classes.add(value); + } + + } + } + return classes; + } + + private Set> generatedWrapperBeanClass() { + DataBinding b = getDataBinding(); + if (b.getClass().getName().endsWith("JAXBDataBinding") + && schemaLocations == null) { + ServiceInfo serviceInfo = getService().getServiceInfos().get(0); + WrapperClassGenerator wrapperGen = new WrapperClassGenerator(this, + serviceInfo.getInterface(), + getQualifyWrapperSchema()); + return wrapperGen.generate(); + } + return Collections.emptySet(); + } + + @Override + protected void buildServiceFromClass() { + super.buildServiceFromClass(); + getService().put(WS_FEATURES, getWsFeatures()); + } + + protected void initializeParameter(MessagePartInfo part, Class rawClass, Type type) { + if (implInfo.isWebServiceProvider()) { + part.setTypeQName(XMLSchemaQNames.XSD_ANY); + part.setTypeClass(rawClass); + return; + } + super.initializeParameter(part, rawClass, type); + } +} diff --git a/war/src/test/resources/META-INF/ejb-jar.xml b/war/src/test/resources/META-INF/ejb-jar.xml new file mode 100644 index 0000000..433757b --- /dev/null +++ b/war/src/test/resources/META-INF/ejb-jar.xml @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/war/src/test/resources/logging.properties b/war/src/test/resources/logging.properties new file mode 100644 index 0000000..c721942 --- /dev/null +++ b/war/src/test/resources/logging.properties @@ -0,0 +1,34 @@ +# Add handlers to the root logger. +# These are inherited by all other loggers. +handlers=java.util.logging.ConsoleHandler, java.util.logging.FileHandler + +# Configure the ConsoleHandler. +# ConsoleHandler uses java.util.logging.SimpleFormatter by default. +# Even though the root logger has the same level as this, +# the next line is still needed because we're configuring a handler, +# not a logger, and handlers don't inherit properties from the root logger. +java.util.logging.ConsoleHandler.level=FINE + +# Configure the FileHandler. +# FileHandler uses java.util.logging.XMLFormatter by default. +java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter +java.util.logging.FileHandler.level=FINEST + +# The following special tokens can be used in the pattern property +# which specifies the location and name of the log file. +# / - standard path separator +# %t - system temporary directory +# %h - value of the user.home system property +# %g - generation number for rotating logs +# %u - unique number to avoid conflicts +# FileHandler writes to %h/demo0.log by default. +java.util.logging.FileHandler.pattern=target/bc-syncro-test.log + +# Set the logging level of the root logger. +# Levels from lowest to highest are +# FINEST, FINER, FINE, CONFIG, INFO, WARNING and SEVERE. +# The default level for all loggers and handlers is INFO. +.level=INFO + +# Specify logging levels for specific namespaces. +be.infrabel.a087=FINEST \ No newline at end of file