001: /*
002: * $Header: /export/home/cvsroot/MyPersonalizerRepository/MyPersonalizer/Subsystems/Kernel/Sources/es/udc/mypersonalizer/kernel/model/repository/sql/plain/PlainSerializableObjectAccessor.java,v 1.1.1.1 2004/03/25 12:08:36 fbellas Exp $
003: * $Revision: 1.1.1.1 $
004: * $Date: 2004/03/25 12:08:36 $
005: *
006: * =============================================================================
007: *
008: * Copyright (c) 2003, The MyPersonalizer Development Group
009: * (http://www.tic.udc.es/~fbellas/mypersonalizer/index.html) at
010: * University Of A Coruna
011: * All rights reserved.
012: *
013: * Redistribution and use in source and binary forms, with or without
014: * modification, are permitted provided that the following conditions are met:
015: *
016: * - Redistributions of source code must retain the above copyright notice,
017: * this list of conditions and the following disclaimer.
018: *
019: * - Redistributions in binary form must reproduce the above copyright notice,
020: * this list of conditions and the following disclaimer in the documentation
021: * and/or other materials provided with the distribution.
022: *
023: * - Neither the name of the University Of A Coruna nor the names of its
024: * contributors may be used to endorse or promote products derived from
025: * this software without specific prior written permission.
026: *
027: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
028: * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
029: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
030: * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
031: * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
032: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
033: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
034: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
035: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
036: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
037: * POSSIBILITY OF SUCH DAMAGE.
038: *
039: */
040:
041: package es.udc.mypersonalizer.kernel.model.repository.sql.plain;
042:
043: import java.util.Collection;
044: import java.sql.Connection;
045:
046: import es.udc.mypersonalizer.kernel.model.repository.sql.storers.SerializableObject;
047: import es.udc.mypersonalizer.kernel.model.repository.sql.storers.SerializableObjectStorer;
048: import es.udc.mypersonalizer.kernel.util.exceptions.DuplicateInstanceException;
049: import es.udc.mypersonalizer.kernel.util.exceptions.InstanceNotFoundException;
050: import es.udc.mypersonalizer.kernel.util.exceptions.InternalErrorException;
051:
052: /**
053: * A class providing operations for accessing serializable objects. The
054: * implementation uses the {@link TransactionManager} which returns pooled
055: * connections, and needs to rely on the storer to perform the requested
056: * operation.
057: *
058: * @author Fernando Bellas
059: * @since 1.0
060: */
061: public class PlainSerializableObjectAccessor {
062:
063: /**
064: * Suffix for identifiers of serialized objects representing meta-services
065: * (instances of
066: * {@link es.udc.mypersonalizer.kernel.model.metainfo.MetaService}).
067: */
068: public static final String SERVICE_SPECIFICATION_SUFFIX = "MetaService";
069:
070: /**
071: * Suffix for identifiers of serialized objects representing service
072: * configurations (instances of
073: * {@link es.udc.mypersonalizer.kernel.model.repository.interfaces.ServiceConfiguration}).
074: */
075: public static final String SERVICE_CONFIGURATION_SUFFIX = "ServiceConfiguration";
076:
077: /**
078: * Suffix for identifiers of serialized objects representing service
079: * personalization prototypes (instances of
080: * {@link es.udc.mypersonalizer.kernel.model.repository.interfaces.ServicePrototype}).
081: */
082: public static final String SERVICE_PROTOTYPE_SUFFIX = "ServicePrototype";
083:
084: /**
085: * Suffix for identifiers of serialized objects representing service
086: * permissions (instances of
087: * {@link es.udc.mypersonalizer.kernel.model.repository.interfaces.ServicePermissions}).
088: */
089: public static final String SERVICE_PERMISSIONS_SUFFIX = "ServicePermissions";
090:
091: /**
092: * Suffix for identifiers of serialized objects representing workspace
093: * definitions (instances of
094: * {@link es.udc.mypersonalizer.kernel.model.repository.interfaces.WorkspaceDefinition}).
095: */
096: public static final String WORKSPACE_DEFINITION_SUFFIX = "WorkspaceDefinition";
097:
098: private SerializableObjectStorer storer;
099:
100: /**
101: * Creates an instance of this accessor.
102: */
103: public PlainSerializableObjectAccessor() {
104: storer = new SerializableObjectStorer();
105: }
106:
107: /**
108: * Finds a serializable object.
109: *
110: * @param serializableObjectIdentifier the identifier of the serializable
111: * object to be found
112: * @return the serializable object
113: * @throws InternalErrorException if a severe failure occured
114: * @throws InstanceNotFoundException if it was unable to find the
115: * serializable object
116: */
117: public SerializableObject findSerializableObject(
118: String serializableObjectIdentifier)
119: throws InternalErrorException, InstanceNotFoundException {
120:
121: Transaction transaction = null;
122:
123: try {
124:
125: /* Get the transaction and the associated connection. */
126: transaction = TransactionManager.getInstance()
127: .getTransaction(Transaction.TRANSACTION_SUPPORTS);
128: Connection connection = transaction.getConnection();
129:
130: /* Delegate on the storer. */
131: SerializableObject serializableObject = storer
132: .findSerializableObject(connection,
133: serializableObjectIdentifier);
134:
135: /* Release transaction and return result. */
136: transaction.release();
137:
138: return serializableObject;
139:
140: } catch (InternalErrorException e) {
141: rollbackTransaction(transaction);
142: throw e;
143: } catch (InstanceNotFoundException e) {
144: transaction.release();
145: throw e;
146: } catch (RuntimeException e) {
147: rollbackTransaction(transaction);
148: throw new InternalErrorException(e);
149: }
150:
151: }
152:
153: /**
154: * Finds serializable objects by pattern.
155: *
156: * @param pattern the search pattern
157: * @return the found serializable objects
158: * @throws InternalErrorException if a severe failure occured
159: */
160: public Collection findSerializableObjectsByPattern(String pattern)
161: throws InternalErrorException {
162:
163: Transaction transaction = null;
164:
165: try {
166:
167: /* Get the transaction and the associated connection. */
168: transaction = TransactionManager.getInstance()
169: .getTransaction(Transaction.TRANSACTION_SUPPORTS);
170: Connection connection = transaction.getConnection();
171:
172: /* Delegate on the storer. */
173: Collection serializableObjects = storer
174: .findSerializableObjectsByPattern(connection,
175: pattern);
176:
177: /* Release transaction and return result. */
178: transaction.release();
179:
180: return serializableObjects;
181:
182: } catch (InternalErrorException e) {
183: rollbackTransaction(transaction);
184: throw e;
185: } catch (RuntimeException e) {
186: rollbackTransaction(transaction);
187: throw new InternalErrorException(e);
188: }
189: }
190:
191: /**
192: * Removes a serializable object.
193: *
194: * @param serializableObjectIdentifier the identifier of the serializable
195: * object to be removed
196: * @throws InternalErrorException if a severe failure occured
197: * @throws InstanceNotFoundException if it was unable to find the
198: * serializable object to be removed
199: */
200: public void removeSerializableObject(
201: String serializableObjectIdentifier)
202: throws InternalErrorException, InstanceNotFoundException {
203:
204: Transaction transaction = null;
205:
206: try {
207:
208: /* Get the transaction and the associated connection. */
209: transaction = TransactionManager.getInstance()
210: .getTransaction(Transaction.TRANSACTION_REQUIRED);
211: Connection connection = transaction.getConnection();
212:
213: /* Delegate on the storer. */
214: storer.removeSerializableObject(connection,
215: serializableObjectIdentifier);
216:
217: /* Release transaction. */
218: transaction.release();
219:
220: } catch (InternalErrorException e) {
221: rollbackTransaction(transaction);
222: throw e;
223: } catch (InstanceNotFoundException e) {
224: transaction.release();
225: throw e;
226: } catch (RuntimeException e) {
227: rollbackTransaction(transaction);
228: throw new InternalErrorException(e);
229: }
230: }
231:
232: /**
233: * Updates a serializable object.
234: *
235: * @param serializableObject the new serializable object that replaces
236: * the old one
237: * @throws InternalErrorException if a severe failure occured
238: * @throws InstanceNotFoundException if it was unable to find the
239: * serializable object to be removed
240: */
241: public void updateSerializableObject(
242: SerializableObject serializableObject)
243: throws InternalErrorException, InstanceNotFoundException {
244:
245: Transaction transaction = null;
246:
247: try {
248:
249: /* Get the transaction and the associated connection. */
250: transaction = TransactionManager.getInstance()
251: .getTransaction(Transaction.TRANSACTION_REQUIRED);
252: Connection connection = transaction.getConnection();
253:
254: /* Delegate on the storer. */
255: storer.updateSerializableObject(connection,
256: serializableObject);
257:
258: /* Release transaction. */
259: transaction.release();
260:
261: } catch (InternalErrorException e) {
262: rollbackTransaction(transaction);
263: throw e;
264: } catch (InstanceNotFoundException e) {
265: transaction.release();
266: throw e;
267: } catch (RuntimeException e) {
268: rollbackTransaction(transaction);
269: throw new InternalErrorException(e);
270: }
271: }
272:
273: /**
274: * Adds a serializable object.
275: *
276: * @param serializableObject the new serializable object to be added
277: * @throws InternalErrorException if a severe failure occured
278: * @throws DuplicateInstanceException if the serializable object already
279: * exists
280: */
281: public void addSerializableObject(
282: SerializableObject serializableObject)
283: throws InternalErrorException, DuplicateInstanceException {
284:
285: Transaction transaction = null;
286:
287: try {
288:
289: /* Get the transaction and the associated connection. */
290: transaction = TransactionManager.getInstance()
291: .getTransaction(Transaction.TRANSACTION_REQUIRED);
292: Connection connection = transaction.getConnection();
293:
294: /* Delegate on the storer. */
295: storer
296: .addSerializableObject(connection,
297: serializableObject);
298:
299: /* Release transaction. */
300: transaction.release();
301:
302: } catch (InternalErrorException e) {
303: rollbackTransaction(transaction);
304: throw e;
305: } catch (DuplicateInstanceException e) {
306: transaction.release();
307: throw e;
308: } catch (RuntimeException e) {
309: rollbackTransaction(transaction);
310: throw new InternalErrorException(e);
311: }
312: }
313:
314: private void rollbackTransaction(Transaction transaction)
315: throws InternalErrorException {
316:
317: if (transaction != null) {
318: transaction.rollback();
319: }
320: }
321:
322: }
|