diff options
Diffstat (limited to '')
20 files changed, 2153 insertions, 0 deletions
diff --git a/sandbox/old/contrib/persistence/store.jdbc/.ruleset b/sandbox/old/contrib/persistence/store.jdbc/.ruleset new file mode 100644 index 0000000000..a1547fea92 --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/.ruleset @@ -0,0 +1,190 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + * 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. +--> +<ruleset name="pmd-eclipse"> + <description>PMD Plugin preferences rule set</description> + + + <rule ref="rulesets/basic.xml/BooleanInstantiation"/> + <rule ref="rulesets/basic.xml/CollapsibleIfStatements"/> + <rule ref="rulesets/basic.xml/DoubleCheckedLocking"/> +<!--<rule ref="rulesets/basic.xml/EmptyCatchBlock"/>--> +<!--<rule ref="rulesets/basic.xml/EmptyFinallyBlock"/>--> +<!--<rule ref="rulesets/basic.xml/EmptyIfStmt"/>--> + <rule ref="rulesets/basic.xml/EmptyStatementNotInLoop"/> +<!--<rule ref="rulesets/basic.xml/EmptyStaticInitializer"/>--> +<!--<rule ref="rulesets/basic.xml/EmptySwitchStatements"/>--> +<!--<rule ref="rulesets/basic.xml/EmptySynchronizedBlock"/>--> +<!--<rule ref="rulesets/basic.xml/EmptyTryBlock"/>--> +<!--<rule ref="rulesets/basic.xml/EmptyWhileStmt"/>--> + <rule ref="rulesets/basic.xml/ForLoopShouldBeWhileLoop"/> + <rule ref="rulesets/basic.xml/JumbledIncrementer"/> +<!--<rule ref="rulesets/basic.xml/OverrideBothEqualsAndHashcode"/>--> + <rule ref="rulesets/basic.xml/ReturnFromFinallyBlock"/> + <rule ref="rulesets/basic.xml/UnconditionalIfStatement"/> + <rule ref="rulesets/basic.xml/UnnecessaryConversionTemporary"/> + <rule ref="rulesets/basic.xml/UnnecessaryFinalModifier"/> + <rule ref="rulesets/basic.xml/UnnecessaryReturn"/> +<!--<rule ref="rulesets/basic.xml/UselessOverridingMethod"/>--> + +<!--<rule ref="rulesets/braces.xml/ForLoopsMustUseBraces"/>--> +<!--<rule ref="rulesets/braces.xml/IfElseStmtsMustUseBraces"/>--> +<!--<rule ref="rulesets/braces.xml/IfStmtsMustUseBraces"/>--> +<!--<rule ref="rulesets/braces.xml/WhileLoopsMustUseBraces"/>--> + +<!--<rule ref="rulesets/clone.xml/CloneMethodMustImplementCloneable"/>--> +<!--<rule ref="rulesets/clone.xml/CloneThrowsCloneNotSupportedException"/>--> +<!--<rule ref="rulesets/clone.xml/ProperCloneImplementation"/>--> + +<!--<rule ref="rulesets/codesize.xml/CyclomaticComplexity"/>--> +<!--<rule ref="rulesets/codesize.xml/ExcessiveClassLength"/>--> +<!--<rule ref="rulesets/codesize.xml/ExcessiveMethodLength"/>--> +<!--<rule ref="rulesets/codesize.xml/ExcessiveParameterList"/>--> +<!--<rule ref="rulesets/codesize.xml/ExcessivePublicCount"/>--> +<!--<rule ref="rulesets/codesize.xml/TooManyFields"/>--> + +<!--<rule ref="rulesets/controversial.xml/AssignmentInOperand"/>--> +<!--<rule ref="rulesets/controversial.xml/AtLeastOneConstructor"/>--> +<!--<rule ref="rulesets/controversial.xml/CallSuperInConstructor"/>--> +<!--<rule ref="rulesets/controversial.xml/DontImportSun"/>--> +<!--<rule ref="rulesets/controversial.xml/NullAssignment"/>--> +<!--<rule ref="rulesets/controversial.xml/OnlyOneReturn"/>--> +<!--<rule ref="rulesets/controversial.xml/SingularField"/>--> +<!--<rule ref="rulesets/controversial.xml/SuspiciousOctalEscape"/>--> +<!--<rule ref="rulesets/controversial.xml/UnnecessaryConstructor"/>--> +<rule ref="rulesets/controversial.xml/UnnecessaryParentheses"/> +<!--<rule ref="rulesets/controversial.xml/UnusedModifier"/>--> + +<!--<rule ref="rulesets/coupling.xml/CouplingBetweenObjects"/>--> +<!--<rule ref="rulesets/coupling.xml/ExcessiveImports"/>--> +<!--<rule ref="rulesets/coupling.xml/LooseCoupling"/>--> + +<!--<rule ref="rulesets/design.xml/AbstractClassWithoutAbstractMethod"/>--> +<!--<rule ref="rulesets/design.xml/AccessorClassGeneration"/>--> +<!--<rule ref="rulesets/design.xml/AssignmentToNonFinalStatic"/>--> +<!--<rule ref="rulesets/design.xml/AvoidDeeplyNestedIfStmts"/>--> +<!--<rule ref="rulesets/design.xml/AvoidInstanceofChecksInCatchClause"/>--> +<rule ref="rulesets/design.xml/AvoidProtectedFieldInFinalClass"/> +<!--<rule ref="rulesets/design.xml/AvoidReassigningParameters"/>--> +<!--<rule ref="rulesets/design.xml/AvoidSynchronizedAtMethodLevel"/>--> +<!--<rule ref="rulesets/design.xml/BadComparison"/>--> +<!--<rule ref="rulesets/design.xml/CloseConnection"/>--> +<!--<rule ref="rulesets/design.xml/CompareObjectsWithEquals"/>--> +<!--<rule ref="rulesets/design.xml/ConfusingTernary"/>--> +<rule ref="rulesets/design.xml/ConstructorCallsOverridableMethod"/> +<!--<rule ref="rulesets/design.xml/DefaultLabelNotLastInSwitchStmt"/>--> +<!--<rule ref="rulesets/design.xml/FinalFieldCouldBeStatic"/>--> +<rule ref="rulesets/design.xml/IdempotentOperations"/> +<!--<rule ref="rulesets/design.xml/ImmutableField"/>--> +<!--<rule ref="rulesets/design.xml/InstantiationToGetClass"/>--> +<!--<rule ref="rulesets/design.xml/MissingBreakInSwitch"/>--> +<!--<rule ref="rulesets/design.xml/MissingStaticMethodInNonInstantiatableClass"/>--> +<!--<rule ref="rulesets/design.xml/NonCaseLabelInSwitchStatement"/>--> +<!--<rule ref="rulesets/design.xml/NonStaticInitializer"/>--> +<rule ref="rulesets/design.xml/OptimizableToArrayCall"/> +<rule ref="rulesets/design.xml/PositionLiteralsFirstInComparisons"/> +<rule ref="rulesets/design.xml/SimplifyBooleanExpressions"/> +<rule ref="rulesets/design.xml/SimplifyBooleanReturns"/> +<rule ref="rulesets/design.xml/SimplifyConditional"/> +<!--<rule ref="rulesets/design.xml/SwitchDensity"/>--> +<!--<rule ref="rulesets/design.xml/SwitchStmtsShouldHaveDefault"/>--> +<rule ref="rulesets/design.xml/UnnecessaryLocalBeforeReturn"/> +<!--<rule ref="rulesets/design.xml/UseLocaleWithCaseConversions"/>--> +<!--<rule ref="rulesets/design.xml/UseNotifyAllInsteadOfNotify"/>--> +<!--<rule ref="rulesets/design.xml/UseSingleton"/>--> + +<!--<rule ref="rulesets/finalizers.xml/EmptyFinalizer"/>--> +<!--<rule ref="rulesets/finalizers.xml/FinalizeOnlyCallsSuperFinalize"/>--> +<!--<rule ref="rulesets/finalizers.xml/FinalizeOverloaded"/>--> +<!--<rule ref="rulesets/finalizers.xml/FinalizeDoesNotCallSuperFinalize"/>--> +<!--<rule ref="rulesets/finalizers.xml/FinalizeShouldBeProtected"/>--> +<!--<rule ref="rulesets/finalizers.xml/AvoidCallingFinalize"/>--> + +<!--<rule ref="rulesets/imports.xml/DuplicateImports"/>--> +<!--<rule ref="rulesets/imports.xml/DontImportJavaLang"/>--> +<!--<rule ref="rulesets/imports.xml/UnusedImports"/>--> +<!--<rule ref="rulesets/imports.xml/ImportFromSamePackage"/>--> + +<!--<rule ref="rulesets/javabeans.xml/BeanMembersShouldSerialize"/>--> +<!--<rule ref="rulesets/javabeans.xml/MissingSerialVersionUID"/>--> + +<!--<rule ref="rulesets/junit.xml/JUnitStaticSuite"/>--> +<!--<rule ref="rulesets/junit.xml/JUnitSpelling"/>--> +<!--<rule ref="rulesets/junit.xml/JUnitAssertionsShouldIncludeMessage"/>--> +<!--<rule ref="rulesets/junit.xml/JUnitTestsShouldIncludeAssert"/>--> +<!--<rule ref="rulesets/junit.xml/TestClassWithoutTestCases"/>--> +<!--<rule ref="rulesets/junit.xml/UnnecessaryBooleanAssertion"/>--> +<!--<rule ref="rulesets/junit.xml/UseAssertEqualsInsteadOfAssertTrue"/>--> +<!--<rule ref="rulesets/junit.xml/UseAssertSameInsteadOfAssertTrue"/>--> + + <!--<rule ref="rulesets/logging-java.xml/AvoidPrintStackTrace"/>--> + <!--<rule ref="rulesets/logging-java.xml/LoggerIsNotStaticFinal"/>--> + <!--<rule ref="rulesets/logging-java.xml/MoreThanOneLogger"/>--> + <!--<rule ref="rulesets/logging-java.xml/LoggerIsNotStaticFinal"/>--> + <!--<rule ref="rulesets/logging-java.xml/LogBlockWithoutIf"/>--> + <!--<rule ref="rulesets/logging-java.xml/SystemPrintln"/>--> + <!--<rule ref="rulesets/logging-jakarta-commons.xml/UseCorrectExceptionLogging"/>--> + <!--<rule ref="rulesets/logging-jakarta-commons.xml/ProperLogger"/>--> + + <!--<rule ref="rulesets/naming.xml/ShortVariable"/>--> + <!--<rule ref="rulesets/naming.xml/LongVariable"/>--> + <!--<rule ref="rulesets/naming.xml/ShortMethodName"/>--> + <!--<rule ref="rulesets/naming.xml/VariableNamingConventions"/>--> + <!--<rule ref="rulesets/naming.xml/MethodNamingConventions"/>--> + <!--<rule ref="rulesets/naming.xml/ClassNamingConventions"/>--> + <!--<rule ref="rulesets/naming.xml/AbstractNaming"/>--> + <!--<rule ref="rulesets/naming.xml/AvoidDollarSigns"/>--> + <!--<rule ref="rulesets/naming.xml/MethodWithSameNameAsEnclosingClass"/>--> + <!--<rule ref="rulesets/naming.xml/SuspiciousHashcodeMethodName"/>--> + <!--<rule ref="rulesets/naming.xml/SuspiciousConstantFieldName"/>--> + <!--<rule ref="rulesets/naming.xml/AvoidFieldNameMatchingTypeName"/>--> + <!--<rule ref="rulesets/naming.xml/AvoidFieldNameMatchingMethodName"/>--> + <!--<rule ref="rulesets/naming.xml/AvoidNonConstructorMethodsWithClassName"/>--> + <!--<rule ref="rulesets/naming.xml/NoPackage"/>--> + <!--<rule ref="rulesets/naming.xml/PackageCase"/>--> + + <!--<rule ref="rulesets/optimizations.xml/LocalVariableCouldBeFinal"/>--> + <!--<rule ref="rulesets/optimizations.xml/MethodArgumentCouldBeFinal"/>--> + <!--<rule ref="rulesets/optimizations.xml/AvoidInstantiatingObjectsInLoops"/>--> + <!--<rule ref="rulesets/optimizations.xml/UseArrayListInsteadOfVector"/>--> + <!--<rule ref="rulesets/optimizations.xml/SimplifyStartsWith"/>--> + <!--<rule ref="rulesets/optimizations.xml/UseStringBufferForStringAppends"/>--> + + <!--<rule ref="rulesets/strictexception.xml/AvoidCatchingThrowable"/>--> + <!--<rule ref="rulesets/strictexception.xml/SignatureDeclareThrowsException"/>--> + <!--<rule ref="rulesets/strictexception.xml/ExceptionAsFlowControl"/>--> + <!--<rule ref="rulesets/strictexception.xml/AvoidCatchingNPE"/>--> + <!--<rule ref="rulesets/strictexception.xml/AvoidThrowingRawExceptionTypes"/>--> + <!--<rule ref="rulesets/strictexception.xml/AvoidThrowingNullPointerException"/>--> + + <!--<rule ref="rulesets/strings.xml/AvoidDuplicateLiterals"/>--> + <!--<rule ref="rulesets/strings.xml/StringInstantiation"/>--> + <!--<rule ref="rulesets/strings.xml/StringToString"/>--> + <!--<rule ref="rulesets/strings.xml/AvoidConcatenatingNonLiteralsInStringBuffer"/>--> + <!--<rule ref="rulesets/strings.xml/UnnecessaryCaseChange"/>--> + + <!--<rule ref="rulesets/sunsecure.xml/MethodReturnsInternalArray"/>--> + <!--<rule ref="rulesets/sunsecure.xml/ArrayIsStoredDirectly"/>--> + + <rule ref="rulesets/unusedcode.xml/UnusedLocalVariable"/> + <rule ref="rulesets/unusedcode.xml/UnusedPrivateField"/> + <rule ref="rulesets/unusedcode.xml/UnusedPrivateMethod"/> + <!--<rule ref="rulesets/unusedcode.xml/UnusedFormalParameter"/>--> + +</ruleset> diff --git a/sandbox/old/contrib/persistence/store.jdbc/LICENSE.txt b/sandbox/old/contrib/persistence/store.jdbc/LICENSE.txt new file mode 100755 index 0000000000..0084319535 --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/LICENSE.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, serviceDefinition marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed 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. diff --git a/sandbox/old/contrib/persistence/store.jdbc/NOTICE.txt b/sandbox/old/contrib/persistence/store.jdbc/NOTICE.txt new file mode 100644 index 0000000000..d83ebbe236 --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/NOTICE.txt @@ -0,0 +1,14 @@ +${pom.name} +Copyright (c) 2005 - 2006 The Apache Software Foundation + +Apache Tuscany is an effort undergoing incubation at The Apache Software +Foundation (ASF), sponsored by the Apache Web Services PMC. Incubation is +required of all newly accepted projects until a further review indicates that +the infrastructure, communications, and decision making process have stabilized +in a manner consistent with other successful ASF projects. While incubation +status is not necessarily a reflection of the completeness or stability of the +code, it does indicate that the project has yet to be fully endorsed by the ASF. + +This product includes software developed by +The Apache Software Foundation (http://www.apache.org/). + diff --git a/sandbox/old/contrib/persistence/store.jdbc/pom.xml.off b/sandbox/old/contrib/persistence/store.jdbc/pom.xml.off new file mode 100644 index 0000000000..99030eb722 --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/pom.xml.off @@ -0,0 +1,67 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + * 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. +--> +<project> + + <parent> + <groupId>org.apache.tuscany.sca.services.persistence</groupId> + <artifactId>parent</artifactId> + <version>1.0-incubator-SNAPSHOT</version> + </parent> + <modelVersion>4.0.0</modelVersion> + <artifactId>persistence-store-jdbc</artifactId> + <packaging>jar</packaging> + <name>Apache Tuscany JDBC Store</name> + <description>Defines a JDBC-based persistent store.</description> + + <dependencies> + <dependency> + <groupId>org.apache.tuscany.sca.kernel</groupId> + <artifactId>tuscany-api</artifactId> + <version>${sca.version}</version> + <scope>compile</scope> + </dependency> + <dependency> + <groupId>org.apache.tuscany.sca.kernel</groupId> + <artifactId>tuscany-spi</artifactId> + <version>${sca.version}</version> + <scope>compile</scope> + </dependency> + + <dependency> + <groupId>commons-dbcp</groupId> + <artifactId>commons-dbcp</artifactId> + <version>1.2.1</version> + </dependency> + <dependency> + <groupId>hsqldb</groupId> + <artifactId>hsqldb</artifactId> + <version>1.8.0.7</version> + </dependency> + <dependency> + <groupId>junit</groupId> + <artifactId>junit</artifactId> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.easymock</groupId> + <artifactId>easymock</artifactId> + </dependency> + </dependencies> +</project> diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/Converter.java b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/Converter.java new file mode 100644 index 0000000000..b37ae6cbe5 --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/Converter.java @@ -0,0 +1,134 @@ +/* + * 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.tuscany.service.persistence.store.jdbc; + +import java.io.Serializable; +import java.sql.Connection; +import java.sql.PreparedStatement; + +import org.apache.tuscany.spi.services.store.StoreReadException; +import org.apache.tuscany.spi.services.store.StoreWriteException; + +/** + * Converters mediate the particularities of specific databases and JDBC drivers such as data types during read and + * write operations + * + * @version $Rev$ $Date$ + */ +public interface Converter { + + /** + * Returns the SQL statement to select a record for update + * + * @return the SQL statement to select a record for update + */ + String getSelectUpdateSql(); + + /** + * Returns the SQL statement to add a record + * + * @return the SQL statement to add a record + */ + String getInsertSql(); + + /** + * Returns the SQL statement to update a record + * + * @return the SQL statement to update a record + */ + String getUpdateSql(); + + /** + * Returns the SQL statement to retrieve a record + * + * @return the SQL statement to retrieve a record + */ + String getFindSql(); + + /** + * Returns the SQL statement to remove a record + * + * @return the SQL statement to remove a record + */ + String getDeleteSql(); + + /** + * Returns the SQL statement to remove expired records + * + * @return the SQL statement to remove expired records + */ + String getDeleteExpiredSql(); + + String getDeleteRecordSql(); + + /** + * Writes a new record to the underlying store using batch semantics. That is, the insert will be added as a batch + * operation to the prepared statment. It is the responsibility of the client (i.e. the prepared statement "owner") + * to exectute the statement when the batch threshold is reached. Note implementations must assume auto commit is + * false. + * + * @param stmt + * @param ownerId + * @param id + * @param expiration + * @param object + * @throws org.apache.tuscany.spi.services.store.StoreWriteException + * + */ + void insert(PreparedStatement stmt, String ownerId, String id, long expiration, Serializable object) + throws StoreWriteException; + + /** + * @param stmt + * @param ownerId + * @param id + * @param object + * @throws StoreWriteException + */ + void update(PreparedStatement stmt, String ownerId, String id, Serializable object) throws StoreWriteException; + + /** + * @param stmt + * @param ownerId + * @param id + * @return + * @throws StoreWriteException + */ + boolean findAndLock(PreparedStatement stmt, String ownerId, String id) throws StoreWriteException; + + /** + * Reads a record from the underlying store. Note implementations must assume auto commit is false. + * + * @param conn + * @param ownerId + * @param id + * @return + * @throws StoreReadException + */ + Object read(Connection conn, String ownerId, String id) throws StoreReadException; + + /** + * @param stmt + * @param ownerId + * @param id + * @throws StoreWriteException + */ + void delete(PreparedStatement stmt, String ownerId, String id) throws StoreWriteException; + +} diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/JDBCStore.java b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/JDBCStore.java new file mode 100644 index 0000000000..5bd04e98da --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/JDBCStore.java @@ -0,0 +1,347 @@ +/* + * 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.tuscany.service.persistence.store.jdbc; + +import java.io.Serializable; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import javax.sql.DataSource; + +import org.osoa.sca.annotations.Destroy; +import org.osoa.sca.annotations.EagerInit; +import org.osoa.sca.annotations.Init; +import org.osoa.sca.annotations.Property; +import org.osoa.sca.annotations.Resource; +import org.osoa.sca.annotations.Service; + +import org.apache.tuscany.spi.annotation.Autowire; +import org.apache.tuscany.spi.component.SCAObject; +import org.apache.tuscany.spi.event.AbstractEventPublisher; +import org.apache.tuscany.spi.services.store.RecoveryListener; +import org.apache.tuscany.spi.services.store.Store; +import org.apache.tuscany.spi.services.store.StoreMonitor; +import org.apache.tuscany.spi.services.store.StoreReadException; +import org.apache.tuscany.spi.services.store.StoreWriteException; + +import org.apache.tuscany.api.annotation.Monitor; + +/** + * A store implementation that uses a relational database to persist records transactionally. + * <p/> + * Note this implementation does not yet support destruction callbacks for expired. In order to support this, expired + * records must be rehydrated and deleted individually. + * + * @version $Rev$ $Date$ + */ +@Service(Store.class) +@EagerInit +public class JDBCStore extends AbstractEventPublisher implements Store { + private DataSource dataSource; + private StoreMonitor monitor; + private Converter converter; + // TODO integrate with a core threading scheme + @SuppressWarnings({"FieldCanBeLocal"}) + private ScheduledExecutorService scheduler; + private long reaperInterval = 300000; + private long defaultExpirationOffset = 600000; // 10 minutes + + //private + public JDBCStore(@Resource(mappedName = "StoreDS")DataSource dataSource, + @Autowire Converter converter, + @Monitor StoreMonitor monitor) { + this.dataSource = dataSource; + this.converter = converter; + this.monitor = monitor; + } + + /** + * Returns the maximum default expiration offset for records in the store + * + * @return the maximum default expiration offset for records in the store + */ + @Property + public long getExpirationOffset() { + return defaultExpirationOffset; + } + + /** + * Sets the maximum default expiration offset for records in the store + */ + public void setDefaultExpirationOffset(long defaultExpirationOffset) { + this.defaultExpirationOffset = defaultExpirationOffset; + } + + /** + * Sets the interval for expired entry scanning to be performed + */ + @Property + public void setReaperInterval(long reaperInterval) { + this.reaperInterval = reaperInterval; + } + + /** + * Returns the interval for expired entry scanning to be performed + */ + public long getReaperInterval() { + return reaperInterval; + } + + @Init + public void init() { + this.scheduler = Executors.newSingleThreadScheduledExecutor(); + scheduler.scheduleWithFixedDelay(new Reaper(), reaperInterval, reaperInterval, TimeUnit.MILLISECONDS); + monitor.start("JDBC store started"); + } + + @Destroy + public void destroy() { + scheduler.shutdown(); + monitor.stop("JDBC store stopped"); + } + + public void insertRecord(SCAObject owner, String id, Object object, long expiration) throws StoreWriteException { + if (!(object instanceof Serializable)) { + throw new NonSerializableTypeException("Type must implement serializable", owner.getCanonicalName(), id); + } + Serializable serializable = (Serializable) object; + String canonicalName = owner.getCanonicalName(); + Connection conn = null; + PreparedStatement insertStmt = null; + PreparedStatement updateStmt = null; + long now = System.currentTimeMillis(); + try { + conn = dataSource.getConnection(); + if (now < expiration || expiration == NEVER) { + PreparedStatement stmt = conn.prepareStatement(converter.getSelectUpdateSql()); + if (converter.findAndLock(stmt, canonicalName, id)) { + updateStmt = conn.prepareStatement(converter.getUpdateSql()); + converter.update(updateStmt, canonicalName, id, serializable); + } else { + insertStmt = conn.prepareStatement(converter.getInsertSql()); + converter.insert(insertStmt, canonicalName, id, expiration, serializable); + } + } + try { + if (insertStmt != null) { + insertStmt.executeUpdate(); + } + if (updateStmt != null) { + updateStmt.executeUpdate(); + } + conn.commit(); + } catch (SQLException e) { + try { + conn.rollback(); + } catch (SQLException e2) { + monitor.error(e2); + } + throw new StoreWriteException(owner.getCanonicalName(), id, e); + } + } catch (SQLException e) { + throw new StoreWriteException(owner.getCanonicalName(), id, e); + } finally { + close(insertStmt); + close(updateStmt); + close(conn); + } + } + + public void updateRecord(SCAObject owner, String id, Object object, long expiration) throws StoreWriteException { + if (!(object instanceof Serializable)) { + throw new NonSerializableTypeException("Type must implement serializable", owner.getCanonicalName(), id); + } + Serializable serializable = (Serializable) object; + String canonicalName = owner.getCanonicalName(); + Connection conn = null; + PreparedStatement insertStmt = null; + PreparedStatement updateStmt = null; + try { + conn = dataSource.getConnection(); + conn = dataSource.getConnection(); + conn.setAutoCommit(false); + updateStmt = conn.prepareStatement(converter.getUpdateSql()); + converter.update(updateStmt, canonicalName, id, serializable); + try { + if (updateStmt != null) { + updateStmt.executeUpdate(); + } + conn.commit(); + } catch (SQLException e) { + try { + conn.rollback(); + } catch (SQLException e2) { + monitor.error(e2); + } + throw new StoreWriteException(owner.getCanonicalName(), id, e); + } + } catch (SQLException e) { + throw new StoreWriteException(owner.getCanonicalName(), id, e); + } finally { + close(insertStmt); + close(updateStmt); + close(conn); + } + + } + + public Object readRecord(SCAObject owner, String id) throws StoreReadException { + Connection conn = null; + try { + conn = dataSource.getConnection(); + Object object = converter.read(conn, owner.getCanonicalName(), id); + conn.commit(); + return object; + } catch (SQLException e) { + try { + if (conn != null) { + conn.rollback(); + } + } catch (SQLException e2) { + monitor.error(e2); + } + throw new StoreReadException(owner.getName(), id, e); + } finally { + close(conn); + } + } + + public void removeRecord(SCAObject owner, String id) throws StoreWriteException { + Connection conn = null; + try { + conn = dataSource.getConnection(); + PreparedStatement stmt = conn.prepareStatement(converter.getDeleteRecordSql()); + converter.delete(stmt, owner.getCanonicalName(), id); + stmt.executeUpdate(); + conn.commit(); + } catch (SQLException e) { + try { + if (conn != null) { + conn.rollback(); + } + } catch (SQLException e2) { + monitor.error(e2); + } + throw new StoreWriteException(owner.getCanonicalName(), id, e); + } finally { + close(conn); + } + } + + public void removeRecords() throws StoreWriteException { + Connection conn = null; + PreparedStatement stmt = null; + try { + conn = dataSource.getConnection(); + stmt = conn.prepareStatement(converter.getDeleteSql()); + stmt.executeUpdate(); + } catch (SQLException e) { + throw new StoreWriteException(e); + } finally { + close(stmt, conn); + } + } + + public void recover(RecoveryListener listener) { + throw new UnsupportedOperationException(); + } + + private void close(Connection conn) { + if (conn != null) { + try { + conn.close(); + } catch (SQLException e) { + monitor.error(e); + } + } + } + + private void close(PreparedStatement stmt) { + if (stmt != null) { + try { + stmt.close(); + } catch (SQLException e) { + monitor.error(e); + } + } + } + + private void close(PreparedStatement stmt, Connection conn) { + if (stmt != null) { + try { + stmt.close(); + } catch (SQLException e) { + monitor.error(e); + } + } + if (conn != null) { + try { + conn.close(); + } catch (SQLException e) { + monitor.error(e); + } + } + } + + /** + * Inner class responsible for clearing out expired entries + */ + private class Reaper implements Runnable { + public void run() { + long now = System.currentTimeMillis(); + Connection conn = null; + PreparedStatement stmt = null; + try { + conn = dataSource.getConnection(); + stmt = conn.prepareStatement(converter.getDeleteExpiredSql()); + stmt.setLong(1, now); + stmt.executeUpdate(); + conn.commit(); + } catch (SQLException e) { + if (conn != null) { + try { + conn.rollback(); + } catch (SQLException e1) { + // ignore + } + } + monitor.error(e); + } finally { + if (stmt != null) { + try { + stmt.close(); + } catch (SQLException e) { + // ingnore + } + } + if (conn != null) { + try { + conn.close(); + } catch (SQLException e) { + // ignore + } + } + } + } + } + +} diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/NonSerializableTypeException.java b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/NonSerializableTypeException.java new file mode 100644 index 0000000000..75fdde42d0 --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/NonSerializableTypeException.java @@ -0,0 +1,31 @@ +/* + * 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.tuscany.service.persistence.store.jdbc; + +import org.apache.tuscany.spi.services.store.StoreWriteException; + +/** + * @version $Rev$ $Date$ + */ +public class NonSerializableTypeException extends StoreWriteException { + + public NonSerializableTypeException(String message, String owner, String identifier) { + super(message, owner, identifier); + } +} diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/Record.java b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/Record.java new file mode 100644 index 0000000000..e568481e17 --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/Record.java @@ -0,0 +1,124 @@ +/* + * 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.tuscany.service.persistence.store.jdbc; + +import java.io.Serializable; + +/** + * Represents a persistent object and its metadata. + * <p/> + * Note this class has a natural ordering that is inconsistent with equals. + * + * @version $Rev$ $Date$ + */ +public class Record implements Comparable { + public static final int INSERT = 0; + public static final int UPDATE = 1; + + private String ownerId; + private String id; + private Serializable object; + private long expiration = JDBCStore.NEVER; + private int operation; + + /** + * Creates a new record + * + * @param ownerId + * @param id the unique id of the record + * @param object the object to serialize + * @param expiration the expirary time, {@link org.apache.tuscany.spi.services.store.Store.NEVER} if there is no + * expiration + * @param operation an <code>INSERT</code> or <code>UPDATE</code> operation + */ + public Record(String ownerId, String id, Serializable object, long expiration, int operation) { + this.id = id; + this.object = object; + this.expiration = expiration; + this.operation = operation; + this.ownerId = ownerId; + } + + /** + * Returns the unique object id + * + * @return the unique object id + */ + public String getId() { + return id; + } + + /** + * Returns the object + * + * @return the object + */ + public Serializable getObject() { + return object; + } + + /** + * Sets the object to serialize + * + * @param object the object + */ + public void setObject(Serializable object) { + this.object = object; + } + + /** + * Returns the expiration time + * + * @return the expiration time + */ + public long getExpiration() { + return expiration; + } + + /** + * Returns the type of operation + * + * @return the type of operation + */ + public int getOperation() { + return operation; + } + + public String getOwnerId() { + return ownerId; + } + + public void setOwnerId(String ownerId) { + this.ownerId = ownerId; + } + + public int compareTo(Object o) { + assert o instanceof Record; + Record record = (Record) o; + if (record.getOperation() == operation) { + return 0; + } else if (record.getOperation() == INSERT) { + return 1; + } else if (record.getOperation() == UPDATE) { + return -1; + } else { + throw new AssertionError(); + } + } +} diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/TCCLObjectInputStream.java b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/TCCLObjectInputStream.java new file mode 100644 index 0000000000..1cd18c1b24 --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/TCCLObjectInputStream.java @@ -0,0 +1,42 @@ +/* + * 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.tuscany.service.persistence.store.jdbc; + +import java.io.IOException; +import java.io.InputStream; +import java.io.ObjectInputStream; +import java.io.ObjectStreamClass; + +/** + * Deserializes an object based on the thread context classloader + * + * @version $Rev$ $Date$ + */ +public class TCCLObjectInputStream extends ObjectInputStream { + private final ClassLoader classLoader; + + public TCCLObjectInputStream(InputStream in) throws IOException, SecurityException { + super(in); + this.classLoader = Thread.currentThread().getContextClassLoader(); + } + + protected Class resolveClass(ObjectStreamClass streamClass) throws IOException, ClassNotFoundException { + return classLoader.loadClass(streamClass.getName()); + } +}
\ No newline at end of file diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/converter/AbstractConverter.java b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/converter/AbstractConverter.java new file mode 100644 index 0000000000..1419c5a9fe --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/converter/AbstractConverter.java @@ -0,0 +1,117 @@ +/* + * 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.tuscany.service.persistence.store.jdbc.converter; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectOutputStream; +import java.io.Serializable; +import java.sql.PreparedStatement; +import java.sql.SQLException; + +import org.apache.tuscany.spi.services.store.StoreWriteException; + +import org.apache.tuscany.service.persistence.store.jdbc.Converter; +import org.apache.tuscany.service.persistence.store.jdbc.TCCLObjectInputStream; + +/** + * Base class for <code>Converter</code> implementations + * + * @version $Rev$ $Date$ + */ +public abstract class AbstractConverter implements Converter { + public static final int OWNER = 1; + public static final int ID = 2; + public static final int EXPIRATION = 3; + public static final int DATA = 4; + public static final int OBJECT_UPDATE = 1; + public static final int OWNER_UPDATE = 2; + public static final int ID_UPDATE = 3; + + protected String findSql = "SELECT * FROM CONVERSATION_STATE WHERE OWNER = ? AND ID = ?"; + protected String insertSql = + "INSERT INTO CONVERSATION_STATE (OWNER, ID, EXPIRATION, OBJECT) VALUES (?, ?, ?, ?)"; + protected String updateSql = "UPDATE CONVERSATION_STATE SET OBJECT = ? WHERE OWNER = ? AND ID = ?"; + protected String selectUpdateSql = + "SELECT ID FROM CONVERSATION_STATE WHERE OWNER = ? AND ID = ? FOR UPDATE"; + protected String deleteSql = "DELETE FROM CONVERSATION_STATE WHERE ID = ?"; + protected String deleteExpiredSql = "DELETE FROM CONVERSATION_STATE WHERE EXPIRATION <= ?"; + protected String deleteRecordSql = "DELETE FROM CONVERSATION_STATE WHERE OWNER = ? AND ID = ?"; + + public String getInsertSql() { + return insertSql; + } + + public String getUpdateSql() { + return updateSql; + } + + public String getFindSql() { + return findSql; + } + + public String getDeleteSql() { + return deleteSql; + } + + public String getDeleteExpiredSql() { + return deleteExpiredSql; + } + + public String getSelectUpdateSql() { + return selectUpdateSql; + } + + public String getDeleteRecordSql() { + return deleteRecordSql; + } + + public boolean findAndLock(PreparedStatement stmt, String ownerId, String id) + throws StoreWriteException { + try { + stmt.setString(OWNER, ownerId); + stmt.setString(ID, id); + return stmt.executeQuery().next(); + } catch (SQLException e) { + throw new StoreWriteException(e); + } + } + + public void delete(PreparedStatement stmt, String ownerId, String id) throws StoreWriteException { + try { + stmt.setString(OWNER, ownerId); + stmt.setString(ID, id); + } catch (SQLException e) { + throw new StoreWriteException(e); + } + } + + protected byte[] serialize(Serializable serializable) throws IOException { + ByteArrayOutputStream bas = new ByteArrayOutputStream(); + ObjectOutputStream out = new ObjectOutputStream(bas); + out.writeObject(serializable); + return bas.toByteArray(); + } + + protected Object deserialize(byte[] bytes) throws IOException, ClassNotFoundException { + return new TCCLObjectInputStream(new ByteArrayInputStream(bytes)).readObject(); + } + +} diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/converter/HSQLDBConverter.java b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/converter/HSQLDBConverter.java new file mode 100644 index 0000000000..a85ab5abfa --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/converter/HSQLDBConverter.java @@ -0,0 +1,101 @@ +/* + * 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.tuscany.service.persistence.store.jdbc.converter; + +import java.io.IOException; +import java.io.Serializable; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; + +import org.apache.tuscany.spi.services.store.StoreReadException; + +import org.apache.tuscany.spi.services.store.StoreWriteException; + +/** + * Performs writing and reading operations to HSQLDB + * + * @version $Rev$ $Date$ + */ +public class HSQLDBConverter extends AbstractConverter { + + // HSQLDB does not support SELECT FOR UPDATE + protected String selectUpdateSql = "SELECT ID FROM CONVERSATION_STATE WHERE OWNER = ? AND ID = ?"; + + public String getSelectUpdateSql() { + return selectUpdateSql; + } + + public void insert(PreparedStatement stmt, String ownerId, String id, long expiration, Serializable object) + throws StoreWriteException { + try { + stmt.setString(OWNER, ownerId); + stmt.setString(ID, id); + stmt.setLong(EXPIRATION, expiration); + stmt.setBytes(DATA, serialize(object)); + } catch (SQLException e) { + throw new StoreWriteException(e); + } catch (IOException e) { + throw new StoreWriteException(e); + } + } + + public void update(PreparedStatement stmt, String ownerId, String id, Serializable object) + throws StoreWriteException { + try { + stmt.setBytes(OBJECT_UPDATE, serialize(object)); + stmt.setString(OWNER_UPDATE, ownerId); + stmt.setString(ID_UPDATE, id); + } catch (SQLException e) { + throw new StoreWriteException(e); + } catch (IOException e) { + throw new StoreWriteException(e); + } + } + + public Object read(Connection conn, String ownerId, String id) throws StoreReadException { + PreparedStatement stmt = null; + try { + stmt = conn.prepareStatement(findSql); + stmt.setString(OWNER, ownerId); + stmt.setString(ID, id); + ResultSet rs = stmt.executeQuery(); + boolean more = rs.next(); + if (!more) { + return null; + } + return deserialize(rs.getBytes(DATA)); + } catch (SQLException e) { + throw new StoreReadException(e); + } catch (IOException e) { + throw new StoreReadException(e); + } catch (ClassNotFoundException e) { + throw new StoreReadException(e); + } finally { + if (stmt != null) { + try { + stmt.close(); + } catch (SQLException e) { + // ignore + } + } + } + } +} diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/converter/JDBCConverter.java b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/converter/JDBCConverter.java new file mode 100644 index 0000000000..4ab9ed6749 --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/main/java/org/apache/tuscany/service/persistence/store/jdbc/converter/JDBCConverter.java @@ -0,0 +1,98 @@ +/* + * 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.tuscany.service.persistence.store.jdbc.converter; + +import java.io.BufferedInputStream; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.Serializable; +import java.sql.Blob; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; + +import org.apache.tuscany.spi.services.store.StoreReadException; +import org.apache.tuscany.spi.services.store.StoreWriteException; + +/** + * Performs writing and reading operations to a JDBC driver/database combination that supports Blobs + * + * @version $Rev$ $Date$ + */ +public class JDBCConverter extends AbstractConverter { + + public void insert(PreparedStatement stmt, String ownerId, String id, long expiration, Serializable object) + throws StoreWriteException { + try { + stmt.setString(OWNER, ownerId); + stmt.setString(ID, id); + stmt.setLong(EXPIRATION, expiration); + byte[] data = serialize(object); + InputStream in = new ByteArrayInputStream(data); + stmt.setBinaryStream(DATA, in, data.length); + } catch (SQLException e) { + throw new StoreWriteException(e); + } catch (IOException e) { + throw new StoreWriteException(e); + } + } + + public void update(PreparedStatement stmt, String ownerId, String id, Serializable object) + throws StoreWriteException { + throw new UnsupportedOperationException(); + } + + public Object read(Connection conn, String ownerId, String id) throws StoreReadException { + PreparedStatement stmt = null; + try { + stmt = conn.prepareStatement(findSql); + stmt.setString(OWNER, ownerId); + stmt.setString(ID, id); + ResultSet rs = stmt.executeQuery(); + rs.next(); + Blob blob = rs.getBlob(DATA); + ByteArrayOutputStream out = new ByteArrayOutputStream(); + BufferedInputStream in = new BufferedInputStream(blob.getBinaryStream()); + int b; + byte[] buffer = new byte[1024]; + while ((b = in.read(buffer, 0, 1024)) != -1) { + out.write(buffer, 0, b); + } + return deserialize(out.toByteArray()); + } catch (SQLException e) { + throw new StoreReadException(e); + } catch (IOException e) { + throw new StoreReadException(e); + } catch (ClassNotFoundException e) { + throw new StoreReadException(e); + } finally { + if (stmt != null) { + try { + stmt.close(); + } catch (SQLException e) { + // ignore + } + } + } + } + +}
\ No newline at end of file diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/JDBCStoreInsertTestCase.java b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/JDBCStoreInsertTestCase.java new file mode 100644 index 0000000000..3d8afc2e3b --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/JDBCStoreInsertTestCase.java @@ -0,0 +1,133 @@ +/* + * 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.tuscany.service.persistence.store.jdbc; + +import java.io.Serializable; +import java.sql.ResultSet; +import java.sql.Statement; +import java.util.UUID; +import javax.sql.DataSource; + +import org.apache.tuscany.spi.component.SCAObject; +import org.apache.tuscany.spi.services.store.Store; + +import junit.framework.Assert; +import junit.framework.TestCase; +import org.apache.tuscany.spi.services.store.StoreMonitor; + +import org.apache.tuscany.service.persistence.store.jdbc.converter.AbstractConverter; +import org.apache.tuscany.service.persistence.store.jdbc.converter.HSQLDBConverter; +import org.easymock.EasyMock; + +/** + * Verifies store insert operations using HSQLDB + * + * @version $Rev$ $Date$ + */ +public class JDBCStoreInsertTestCase extends TestCase { + private DataSource ds; + private JDBCStore store; + + public void testInsertMetaData() throws Exception { + SCAObject object = EasyMock.createMock(SCAObject.class); + EasyMock.expect(object.getCanonicalName()).andReturn("foo").atLeastOnce(); + EasyMock.replay(object); + store.init(); + JDBCStoreInsertTestCase.Foo foo = new JDBCStoreInsertTestCase.Foo("test"); + String id = UUID.randomUUID().toString(); + store.insertRecord(object, id, foo, Store.NEVER); + Statement stmt = ds.getConnection().createStatement(); + ResultSet rs = stmt.executeQuery(TestUtils.SELECT_SQL); + rs.next(); + assertEquals(id, rs.getString(AbstractConverter.ID)); + Assert.assertEquals(Store.NEVER, rs.getLong(AbstractConverter.EXPIRATION)); + } + + public void testInsertRead() throws Exception { + store.init(); + SCAObject object = EasyMock.createMock(SCAObject.class); + EasyMock.expect(object.getCanonicalName()).andReturn("foo").atLeastOnce(); + EasyMock.replay(object); + JDBCStoreInsertTestCase.Foo foo = new JDBCStoreInsertTestCase.Foo("test"); + String id = UUID.randomUUID().toString(); + store.insertRecord(object, id, foo, Store.NEVER); + Foo foo2 = (Foo) store.readRecord(object, id); + assertEquals("test", foo2.data); + } + + public void testInsertOverwriteRead() throws Exception { + store.init(); + SCAObject object = EasyMock.createMock(SCAObject.class); + EasyMock.expect(object.getCanonicalName()).andReturn("foo").atLeastOnce(); + EasyMock.replay(object); + JDBCStoreInsertTestCase.Foo foo = new JDBCStoreInsertTestCase.Foo("test"); + String id = UUID.randomUUID().toString(); + store.insertRecord(object, id, foo, Store.NEVER); + foo.data = "test2"; + store.insertRecord(object, id, foo, Store.NEVER); + Foo foo2 = (Foo) store.readRecord(object, id); + assertEquals("test2", foo2.data); + } + + /** + * Verifies multiple resources belonging to different owners but sharing the same id are inserted + */ + public void testMultipleInsert() throws Exception { + SCAObject owner1 = EasyMock.createMock(SCAObject.class); + EasyMock.expect(owner1.getCanonicalName()).andReturn("baz").atLeastOnce(); + EasyMock.replay(owner1); + SCAObject owner2 = EasyMock.createMock(SCAObject.class); + EasyMock.expect(owner2.getCanonicalName()).andReturn("bar").atLeastOnce(); + EasyMock.replay(owner2); + store.init(); + Foo foo1 = new Foo("test"); + String id1 = UUID.randomUUID().toString(); + Foo foo2 = new Foo("test2"); + store.insertRecord(owner1, id1, foo1, Store.NEVER); + store.insertRecord(owner2, id1, foo2, Store.NEVER); + Foo retFoo1 = (Foo) store.readRecord(owner1, id1); + assertEquals("test", retFoo1.data); + Foo retFoo2 = (Foo) store.readRecord(owner2, id1); + assertEquals("test2", retFoo2.data); + } + + + protected void setUp() throws Exception { + super.setUp(); + ds = TestUtils.createTables(); + store = new JDBCStore(ds, new HSQLDBConverter(), EasyMock.createNiceMock(StoreMonitor.class)); + } + + + protected void tearDown() throws Exception { + super.tearDown(); + TestUtils.cleanup(ds); + } + + @SuppressWarnings({"SerializableHasSerializationMethods"}) + public static class Foo implements Serializable { + private static final long serialVersionUID = -4284779882741318884L; + private String data; + + public Foo(String data) { + this.data = data; + } + } + +} diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/JDBCStoreTestCase.java b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/JDBCStoreTestCase.java new file mode 100644 index 0000000000..418899be86 --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/JDBCStoreTestCase.java @@ -0,0 +1,100 @@ +/* + * 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.tuscany.service.persistence.store.jdbc; + +import java.io.Serializable; +import java.util.UUID; +import javax.sql.DataSource; + +import org.apache.tuscany.spi.component.SCAObject; + +import junit.framework.TestCase; +import static org.apache.tuscany.spi.services.store.Store.NEVER; +import org.apache.tuscany.spi.services.store.StoreMonitor; +import org.apache.tuscany.service.persistence.store.jdbc.converter.HSQLDBConverter; +import org.easymock.EasyMock; + +/** + * Verifies store operations using HSQLDB + * + * @version $Rev$ $Date$ + */ +public class JDBCStoreTestCase extends TestCase { + private DataSource ds; + private JDBCStore store; + + public void testNotFound() throws Exception { + store.init(); + SCAObject object = EasyMock.createMock(SCAObject.class); + EasyMock.expect(object.getCanonicalName()).andReturn("foo").atLeastOnce(); + EasyMock.replay(object); + String id = UUID.randomUUID().toString(); + assertNull(store.readRecord(object, id)); + } + + public void testRemoveRecord() throws Exception { + store.init(); + SCAObject object = EasyMock.createMock(SCAObject.class); + EasyMock.expect(object.getCanonicalName()).andReturn("foo").atLeastOnce(); + EasyMock.replay(object); + Foo foo = new Foo("test"); + String id = UUID.randomUUID().toString(); + store.insertRecord(object, id, foo, NEVER); + Foo foo2 = (Foo) store.readRecord(object, id); + assertEquals("test", foo2.data); + store.removeRecord(object, id); + assertNull(store.readRecord(object, id)); + } + + public void testExpirationFromStore() throws Exception { + store.setReaperInterval(10); + store.init(); + SCAObject object = EasyMock.createMock(SCAObject.class); + EasyMock.expect(object.getCanonicalName()).andReturn("foo").atLeastOnce(); + EasyMock.replay(object); + Foo foo = new Foo("test"); + String id = UUID.randomUUID().toString(); + store.insertRecord(object, id, foo, System.currentTimeMillis() + 20); + Thread.sleep(100); + assertNull(store.readRecord(object, id)); + } + + protected void setUp() throws Exception { + super.setUp(); + ds = TestUtils.createTables(); + store = new JDBCStore(ds, new HSQLDBConverter(), EasyMock.createNiceMock(StoreMonitor.class)); + } + + + protected void tearDown() throws Exception { + super.tearDown(); + TestUtils.cleanup(ds); + } + + @SuppressWarnings({"SerializableHasSerializationMethods"}) + public static class Foo implements Serializable { + private static final long serialVersionUID = -4284779882741318884L; + private String data; + + public Foo(String data) { + this.data = data; + } + } + +} diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/JDBCStoreUpdateTestCase.java b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/JDBCStoreUpdateTestCase.java new file mode 100644 index 0000000000..b9b0500572 --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/JDBCStoreUpdateTestCase.java @@ -0,0 +1,102 @@ +/* + * 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.tuscany.service.persistence.store.jdbc; + +import java.io.Serializable; +import java.util.UUID; +import javax.sql.DataSource; + +import org.apache.tuscany.spi.component.SCAObject; + +import junit.framework.TestCase; +import org.apache.tuscany.spi.services.store.Store; +import static org.apache.tuscany.spi.services.store.Store.NEVER; +import org.apache.tuscany.spi.services.store.StoreMonitor; +import org.apache.tuscany.service.persistence.store.jdbc.converter.HSQLDBConverter; +import org.easymock.EasyMock; + +/** + * Verifies store operations using HSQLDB + * + * @version $Rev$ $Date$ + */ +public class JDBCStoreUpdateTestCase extends TestCase { + private DataSource ds; + private JDBCStore store; + + public void testMultipleUpdate() throws Exception { + SCAObject owner1 = EasyMock.createMock(SCAObject.class); + EasyMock.expect(owner1.getCanonicalName()).andReturn("baz").atLeastOnce(); + EasyMock.replay(owner1); + SCAObject owner2 = EasyMock.createMock(SCAObject.class); + EasyMock.expect(owner2.getCanonicalName()).andReturn("bar").atLeastOnce(); + EasyMock.replay(owner2); + store.init(); + Foo foo1 = new Foo("test"); + String id1 = UUID.randomUUID().toString(); + Foo foo2 = new Foo("test2"); + store.insertRecord(owner1, id1, foo1, Store.NEVER); + store.insertRecord(owner2, id1, foo2, Store.NEVER); + foo1.data = "testA"; + foo2.data = "test2A"; + store.updateRecord(owner1, id1, foo1, Store.NEVER); + store.updateRecord(owner2, id1, foo2, Store.NEVER); + Foo retFoo1 = (Foo) store.readRecord(owner1, id1); + assertEquals("testA", retFoo1.data); + Foo retFoo2 = (Foo) store.readRecord(owner2, id1); + assertEquals("test2A", retFoo2.data); + } + + public void testUpdateRead() throws Exception { + store.init(); + SCAObject object = EasyMock.createMock(SCAObject.class); + EasyMock.expect(object.getCanonicalName()).andReturn("foo").atLeastOnce(); + EasyMock.replay(object); + Foo foo = new Foo("test"); + String id = UUID.randomUUID().toString(); + store.insertRecord(object, id, foo, NEVER); + foo.data = "test2"; + store.updateRecord(object, id, foo, Store.NEVER); + Foo foo2 = (Foo) store.readRecord(object, id); + assertEquals("test2", foo2.data); + } + + + protected void setUp() throws Exception { + super.setUp(); + ds = TestUtils.createTables(); + store = new JDBCStore(ds, new HSQLDBConverter(), EasyMock.createNiceMock(StoreMonitor.class)); + } + + protected void tearDown() throws Exception { + super.tearDown(); + TestUtils.cleanup(ds); + } + + @SuppressWarnings({"SerializableHasSerializationMethods"}) + public static class Foo implements Serializable { + private static final long serialVersionUID = -4284779882741318884L; + private String data; + + public Foo(String data) { + this.data = data; + } + } + +} diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/RecordTestCase.java b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/RecordTestCase.java new file mode 100644 index 0000000000..660e906cef --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/RecordTestCase.java @@ -0,0 +1,66 @@ +/* + * 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.tuscany.service.persistence.store.jdbc; + +import java.util.UUID; + +import junit.framework.TestCase; +import static org.apache.tuscany.spi.services.store.Store.NEVER; + +/** + * @version $Rev$ $Date$ + */ +public class RecordTestCase extends TestCase { + + public void testInsertCompare() { + Record record = new Record(null, UUID.randomUUID().toString(), "foo", NEVER, Record.INSERT); + Record record2 = new Record(null, UUID.randomUUID().toString(), "bar", NEVER, Record.INSERT); + assertEquals(0, record.compareTo(record2)); + } + + public void testUpdateCompare() { + Record record = new Record(null, UUID.randomUUID().toString(), "foo", NEVER, Record.UPDATE); + Record record2 = new Record(null, UUID.randomUUID().toString(), "bar", NEVER, Record.UPDATE); + assertEquals(0, record.compareTo(record2)); + } + + public void testInsertUpdateCompare() { + Record record = new Record(null, UUID.randomUUID().toString(), "foo", NEVER, Record.INSERT); + Record record2 = new Record(null, UUID.randomUUID().toString(), "bar", NEVER, Record.UPDATE); + assertEquals(-1, record.compareTo(record2)); + } + + public void testUpdateInsertCompare() { + Record record = new Record(null, UUID.randomUUID().toString(), "foo", NEVER, Record.UPDATE); + Record record2 = new Record(null, UUID.randomUUID().toString(), "bar", NEVER, Record.INSERT); + assertEquals(1, record.compareTo(record2)); + } + + public void testAssertion() { + Record record = new Record(null, UUID.randomUUID().toString(), "foo", NEVER, 4); + Record record2 = new Record(null, UUID.randomUUID().toString(), "bar", NEVER, 5); + try { + record.compareTo(record2); + fail(); + } catch (AssertionError e) { + // expected + } + } + +} diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/TestUtils.java b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/TestUtils.java new file mode 100644 index 0000000000..8fb1c966c9 --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/TestUtils.java @@ -0,0 +1,72 @@ +/* + * 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.tuscany.service.persistence.store.jdbc; + +import java.sql.Connection; +import java.sql.SQLException; +import javax.sql.DataSource; + +import org.apache.commons.dbcp.BasicDataSource; + +/** + * @version $Rev$ $Date$ + */ +public final class TestUtils { + + public static final String CREATE_TABLE = + "CREATE TABLE CONVERSATION_STATE(OWNER VARCHAR, ID VARCHAR, EXPIRATION BIGINT, " + + "OBJECT LONGVARBINARY);"; + + public static final String DROP_TABLE = "DROP TABLE CONVERSATION_STATE IF EXISTS"; + public static final String SELECT_SQL = "SELECT * FROM CONVERSATION_STATE"; + + private TestUtils() { + } + + public static DataSource createTables() throws SQLException { + BasicDataSource ds = new BasicDataSource(); + ds.setDriverClassName("org.hsqldb.jdbcDriver"); + ds.setUrl("jdbc:hsqldb:mem:test"); + Connection conn = null; + try { + conn = ds.getConnection(); + conn.createStatement().execute(CREATE_TABLE); + conn.commit(); + } finally { + if (conn != null) { + conn.close(); + } + } + return ds; + } + + public static void cleanup(DataSource ds) throws SQLException { + Connection conn = null; + try { + conn = ds.getConnection(); + conn.createStatement().execute(DROP_TABLE); + conn.createStatement().execute("SHUTDOWN"); + conn.commit(); + } finally { + if (conn != null) { + conn.close(); + } + } + } +} diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/converter/AbstractConverterTestCase.java b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/converter/AbstractConverterTestCase.java new file mode 100644 index 0000000000..0d8f48e126 --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/converter/AbstractConverterTestCase.java @@ -0,0 +1,88 @@ +/* + * 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.tuscany.service.persistence.store.jdbc.converter; + +import java.io.IOException; +import java.io.Serializable; +import java.sql.Connection; +import java.sql.PreparedStatement; + +import org.apache.tuscany.spi.services.store.StoreReadException; + +import junit.framework.TestCase; +import org.apache.tuscany.spi.services.store.StoreWriteException; + +/** + * @version $Rev$ $Date$ + */ +public class AbstractConverterTestCase extends TestCase { + + public void testSerializeDeserialize() throws Exception { + TestConverter converter = new TestConverter(); + Foo foo = new Foo(); + foo.data = "test"; + byte[] bytes = converter.serialize(foo); + Foo foo2 = (Foo) converter.deserialize(bytes); + assertEquals("test", foo2.data); + } + + private class TestConverter extends AbstractConverter { + + public void insert(PreparedStatement stmt, String ownerId, String id, long expiration, Serializable object) + throws StoreWriteException { + + } + + public void update(PreparedStatement stmt, String ownerId, String id, Serializable object) + throws StoreWriteException { + + } + + public boolean findAndLock(PreparedStatement stmt, + String ownerId, + String id + ) throws StoreWriteException { + return false; + } + + public Object read(Connection conn, String ownerId, String id) throws StoreReadException { + return null; + } + + public void delete(PreparedStatement stmt, String ownerId, String id) throws StoreWriteException { + + } + + @Override + public byte[] serialize(Serializable serializable) throws IOException { + return super.serialize(serializable); + } + + @Override + public Object deserialize(byte[] bytes) throws IOException, ClassNotFoundException { + return super.deserialize(bytes); + } + } + + @SuppressWarnings({"SerializableHasSerializationMethods"}) + private static class Foo implements Serializable { + private static final long serialVersionUID = -3774909621298751358L; + private String data; + } +} diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/converter/HSQLDBConverterTestCase.java b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/converter/HSQLDBConverterTestCase.java new file mode 100644 index 0000000000..472c523217 --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/converter/HSQLDBConverterTestCase.java @@ -0,0 +1,89 @@ +/* + * 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.tuscany.service.persistence.store.jdbc.converter; + +import java.io.Serializable; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.util.UUID; +import javax.sql.DataSource; + +import org.apache.tuscany.spi.services.store.Store; + +import junit.framework.TestCase; +import org.apache.tuscany.service.persistence.store.jdbc.Converter; +import static org.apache.tuscany.service.persistence.store.jdbc.TestUtils.cleanup; +import static org.apache.tuscany.service.persistence.store.jdbc.TestUtils.createTables; + +/** + * @version $Rev$ $Date$ + */ +public class HSQLDBConverterTestCase extends TestCase { + + private Converter converter; + private DataSource ds; + + public void testWriteRead() throws Exception { + Connection conn = ds.getConnection(); + conn.setAutoCommit(false); + PreparedStatement stmt = conn.prepareStatement(converter.getInsertSql()); + String id = UUID.randomUUID().toString(); + Foo foo = new Foo(); + foo.data = "test"; + converter.insert(stmt, "foo", id, Store.NEVER, foo); + stmt.addBatch(); + stmt.execute(); + stmt.close(); + conn.commit(); + conn.close(); + conn = ds.getConnection(); + conn.setAutoCommit(false); + Foo foo2 = (Foo) converter.read(conn, "foo", id); + assertEquals("test", foo2.data); + conn.commit(); + conn.close(); + } + + public void testNotFound() throws Exception { + Connection conn = ds.getConnection(); + conn.setAutoCommit(false); + String id = UUID.randomUUID().toString(); + assertNull(converter.read(conn, null, id)); + conn.commit(); + conn.close(); + } + + protected void setUp() throws Exception { + super.setUp(); + converter = new HSQLDBConverter(); + ds = createTables(); + } + + protected void tearDown() throws Exception { + super.tearDown(); + cleanup(ds); + } + + @SuppressWarnings({"SerializableHasSerializationMethods"}) + private static class Foo implements Serializable { + private static final long serialVersionUID = -6119188073169441225L; + private String data; + } + +} diff --git a/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/integration/BootstrapTestCase.java b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/integration/BootstrapTestCase.java new file mode 100644 index 0000000000..4225cf65ba --- /dev/null +++ b/sandbox/old/contrib/persistence/store.jdbc/src/test/java/org/apache/tuscany/service/persistence/store/jdbc/integration/BootstrapTestCase.java @@ -0,0 +1,36 @@ +/* + * 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.tuscany.service.persistence.store.jdbc.integration; + +import junit.framework.TestCase; + +/** + * @version $Rev$ $Date$ + */ +public class BootstrapTestCase extends TestCase { + + public void testBoot() throws Exception { + // TODO + } + + protected void setUp() throws Exception { + super.setUp(); + + } +} |