r548 - trunk/wikitty-api/src/main/java/org/nuiton/wikitty/services - Wikitty-commits

1 Dec 2010

Author: bpoussin
Date: 2010-12-01 16:32:39 +0100 (Wed, 01 Dec 2010)
New Revision: 548

Url: http://nuiton.org/repositories/revision/wikitty/548

Log:
Anomalie #1122: Wikitty migration open new transaction instead of using current transaction
Refactor all WikittyTransaction usage to put current transaction in ThreadLocal. Each thread has own transaction for reuse

Modified:
   trunk/wikitty-api/src/main/java/org/nuiton/wikitty/services/WikittyServiceStorage.java
   trunk/wikitty-api/src/main/java/org/nuiton/wikitty/services/WikittyTransaction.java

Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/services/WikittyServiceStorage.java
===================================================================

--- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/services/WikittyServiceStorage.java	2010-12-01 14:37:43 UTC (rev 547)
+++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/services/WikittyServiceStorage.java	2010-12-01 15:32:39 UTC (rev 548)
@@ -169,45 +169,9 @@
         }
     }
 
-//    @Override
-//    public UpdateResponse store(String securityToken, WikittyTransaction transaction,
-//            Collection<Wikitty> wikitties, boolean force) {
-//        if (!(wikitties instanceof Set)) {
-//            // use all time Set to prevent duplicated wikitty in collection
-//            wikitties = new LinkedHashSet<Wikitty>(wikitties);
-//        }
-//        checkConstraint(wikitties);
-//
-//        // update/store extension if necessary
-//        Set<WikittyExtension> allExtensions = new LinkedHashSet<WikittyExtension>();
-//        for (Wikitty w : wikitties) {
-//            // collect all extensions used by all wikitties
-//            allExtensions.addAll(w.getExtensions());
-//        }
-//
-//        // try to commit command
-//        UpdateResponse extUpdate = getExtensionStorage().store(transaction, allExtensions);
-//        UpdateResponse wikUpdate = getWikittyStorage().store(transaction, wikitties, force);
-//        UpdateResponse indexUpdate = getSearchEngin().store(transaction, wikitties);
-//
-//        UpdateResponse result = new UpdateResponse();
-//        // prepare update client response
-//        result.add(extUpdate);
-//        result.add(wikUpdate);
-//        result.add(indexUpdate);
-//
-//        return result;
-//    }
     @Override
     public WikittyEvent store(String securityToken,
             Collection<Wikitty> wikitties, boolean force) {
-        WikittyEvent result = store(securityToken, null, wikitties, force);
-        return result;
-    }
-
-    protected WikittyEvent store(String securityToken,
-            WikittyTransaction transaction,
-            Collection<Wikitty> wikitties, boolean force) {
         if (!(wikitties instanceof Set)) {
             // use all time Set to prevent duplicated wikitty in collection
             wikitties = new LinkedHashSet<Wikitty>(wikitties);
@@ -221,38 +185,38 @@
             allExtensions.addAll(w.getExtensions());
         }
 
-        boolean txCreated = false;
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            if (transaction == null) {
-                transaction = new WikittyTransaction();
-                txCreated = true;
-                transaction.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
             }
 
             // try to commit command
             WikittyEvent extUpdate =
-                    getExtensionStorage().store(transaction, allExtensions);
+                    getExtensionStorage().store(tx, allExtensions);
             WikittyEvent wikUpdate =
-                    getWikittyStorage().store(transaction, wikitties, force);
-            getSearchEngin().store(transaction, wikitties);
+                    getWikittyStorage().store(tx, wikitties, force);
+            getSearchEngin().store(tx, wikitties);
 
             WikittyEvent result = new WikittyEvent(this);
             // prepare update client response
             result.add(extUpdate);
             result.add(wikUpdate);
 
-            if (txCreated) {
-                transaction.commit();
+            if (txBeginHere) {
+                tx.commit();
             }
             return result;
         } catch (WikittyException ex) {
-            if (transaction != null) {
-                transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
             }
             throw ex;
         } catch (Exception eee) {
-            if (transaction != null) {
-                transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
             }
             throw new WikittyException("Can't store wikitty", eee);
         }
@@ -260,16 +224,29 @@
 
     @Override
     public List<String> getAllExtensionIds(String securityToken) {
-        WikittyTransaction transaction = new WikittyTransaction();
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            transaction.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
+            }
 
-            List<String> result = getExtensionStorage().getAllExtensionIds(transaction);
-            
-            transaction.commit();
+            List<String> result = getExtensionStorage().getAllExtensionIds(tx);
+
+            if (txBeginHere) {
+                tx.commit();
+            }
             return result;
+        } catch (WikittyException ex) {
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
+            throw ex;
         } catch (Exception eee) {
-            transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
             throw new WikittyException("Can't retrieve all extension's ids", eee);
         }
     }
@@ -277,74 +254,75 @@
     @Override
     public List<String> getAllExtensionsRequires(
             String securityToken, String extensionName) {
-        WikittyTransaction transaction = new WikittyTransaction();
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            transaction.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
+            }
 
             List<String> result = getExtensionStorage()
-                    .getAllExtensionsRequires(transaction, extensionName);
-            
-            transaction.commit();
+                    .getAllExtensionsRequires(tx, extensionName);
+
+            if (txBeginHere) {
+                tx.commit();
+            }
             return result;
+        } catch (WikittyException ex) {
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
+            throw ex;
         } catch (Exception eee) {
-            transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
             throw new WikittyException(String.format(
                     "Can't retrieve all required extension for %s", extensionName), eee);
         }
     }
 
     @Override
-    public WikittyEvent storeExtension(
-            String securityToken, Collection<WikittyExtension> exts) {
-        WikittyEvent result = storeExtension(securityToken, null, exts);
-        return result;
-    }
-
-    @Override
-    public WikittyEvent deleteExtension(
-            String securityToken, Collection<String> extNames) {
-        WikittyEvent result = deleteExtension(securityToken, null, extNames);
-        return result;
-    }
-
-    protected WikittyEvent storeExtension(String securityToken,
-            WikittyTransaction transaction, Collection<WikittyExtension> exts) {
-        boolean txCreated = false;
+    public WikittyEvent storeExtension(String securityToken,
+            Collection<WikittyExtension> exts) {
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            if (transaction == null) {
-                transaction = new WikittyTransaction();
-                txCreated = true;
-                transaction.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
             }
 
             WikittyEvent result =
-                    getExtensionStorage().store(transaction, exts);
+                    getExtensionStorage().store(tx, exts);
             
-            if (txCreated) {
-                transaction.commit();
+            if (txBeginHere) {
+                tx.commit();
             }
             return result;
         } catch (WikittyException ex) {
-            if (transaction != null) {
-                transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
             }
             throw ex;
         } catch (Exception eee) {
-            if (transaction != null) {
-                transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
             }
             throw new WikittyException("Can't store extensions", eee);
         }
     }
 
-    protected WikittyEvent deleteExtension(String securityToken,
-            WikittyTransaction transaction, Collection<String> extNames) {
-        boolean txCreated = false;
+    @Override
+    public WikittyEvent deleteExtension(
+            String securityToken, Collection<String> extNames) {
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            if (transaction == null) {
-                transaction = new WikittyTransaction();
-                txCreated = true;
-                transaction.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
             }
 
             // check that all extensions are not used
@@ -353,7 +331,7 @@
                 Criteria criteria = Search.query().eq(Element.ELT_EXTENSION, name).criteria();
                 criteria.setEndIndex(0); // result is not use, just numFound
                 PagedResult<String> wikittyWithExt = findAllByCriteria(
-                        securityToken, transaction, criteria);
+                        securityToken, criteria);
                 int numFound = wikittyWithExt.getNumFound();
                 if (numFound > 0) {
                     throw new WikittyException(String.format(
@@ -364,20 +342,20 @@
             }
 
             WikittyEvent result =
-                    getExtensionStorage().delete(transaction, extNames);
+                    getExtensionStorage().delete(tx, extNames);
 
-            if (txCreated) {
-                transaction.commit();
+            if (txBeginHere) {
+                tx.commit();
             }
             return result;
         } catch (WikittyException ex) {
-            if (transaction != null) {
-                transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
             }
             throw ex;
         } catch (Exception eee) {
-            if (transaction != null) {
-                transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
             }
             throw new WikittyException("Can't delete extensions", eee);
         }
@@ -386,38 +364,32 @@
     @Override
     public WikittyExtension restoreExtension(
             String securityToken, String extensionId) {
-        WikittyExtension result = restoreExtension(securityToken, null, extensionId);
-        return result;
-    }
-
-    protected WikittyExtension restoreExtension(
-            String securityToken, WikittyTransaction transaction, String extensionId) {
-        boolean txCreated = false;
+         WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            if (transaction == null) {
-                transaction = new WikittyTransaction();
-                txCreated = true;
-                transaction.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
             }
 
             //split the id to ensure that version is normalized
             String name = WikittyExtension.computeName(extensionId);
             String version = WikittyExtension.computeVersion(extensionId);
 
-            WikittyExtension result = getExtensionStorage().restore(transaction, name, version);
+            WikittyExtension result = getExtensionStorage().restore(tx, name, version);
 
-            if (txCreated) {
-                transaction.commit();
+            if (txBeginHere) {
+                tx.commit();
             }
             return result;
         } catch (WikittyException ex) {
-            if (transaction != null) {
-                transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
             }
             throw ex;
         } catch (Exception eee) {
-            if (transaction != null) {
-                transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
             }
             throw new WikittyException("Can't restore extensions", eee);
         }
@@ -426,92 +398,111 @@
     @Override
     public WikittyExtension restoreExtensionLastVersion(
             String securityToken, String name) {
-        WikittyExtension result = restoreExtensionLastVersion(securityToken, null, name);
-        return result;
-    }
-
-    protected WikittyExtension restoreExtensionLastVersion(String securityToken,
-            WikittyTransaction transaction, String name) {
-        String version = getExtensionStorage().getLastVersion(transaction, name);
-        if(version == null) {
-            return null;
-        }
-
-        boolean txCreated = false;
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            if (transaction == null) {
-                transaction = new WikittyTransaction();
-                txCreated = true;
-                transaction.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
             }
 
-            WikittyExtension result = getExtensionStorage().restore(transaction, name, version);
+            String version = getExtensionStorage().getLastVersion(tx, name);
+            if (version == null) {
+                if (txBeginHere) {
+                    tx.commit();
+                }
+                return null;
+            }
 
-            if (txCreated) {
-                transaction.commit();
+
+            WikittyExtension result = getExtensionStorage().restore(tx, name, version);
+
+            if (txBeginHere) {
+                tx.commit();
             }
             return result;
         } catch (WikittyException ex) {
-            if (transaction != null) {
-                transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
             }
             throw ex;
         } catch (Exception eee) {
-            if (transaction != null) {
-                transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
             }
             throw new WikittyException("Can't store extensions", eee);
         }
     }
 
-    protected Wikitty restore(String securityToken,
-            WikittyTransaction transaction, String id) {
-        if (id == null) {
-            return null;
-        }
-        if (!getWikittyStorage().exists(transaction, id)) {
-            // object doesn't exist, we return null
-            return null;
-        }
+    /**
+     * restore one wikitty
+     * @param securityToken
+     * @param id
+     * @return
+     */
+    protected Wikitty restore(String securityToken, String id) {
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
+        try {
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
+            }
 
-        if (getWikittyStorage().isDeleted(transaction, id)) {
-            // object deleted, we return null
-            return null;
+            if (id == null) {
+                return null;
+            }
+            if (!getWikittyStorage().exists(tx, id)) {
+                // object doesn't exist, we return null
+                return null;
+            }
+
+            if (getWikittyStorage().isDeleted(tx, id)) {
+                // object deleted, we return null
+                return null;
+            }
+            Wikitty result = getWikittyStorage().restore(tx, id);
+            if (result != null) {
+                result = upgradeData(securityToken, result);
+            }
+            
+            if (txBeginHere) {
+                tx.commit();
+            }
+            return result;
+        } catch (WikittyException ex) {
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
+            throw ex;
+        } catch (Exception eee) {
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
+            throw new WikittyException("Can't store extensions", eee);
         }
-        Wikitty result = getWikittyStorage().restore(transaction, id);
-        if(result != null) {
-            result = upgradeData(securityToken, transaction, result);
-        }
-        return result;
     }
 
     @Override
     public List<Wikitty> restore(String securityToken, List<String> ids) {
-        List<Wikitty> result = restore(securityToken, null, ids);
-        return result;
-    }
-
-    protected List<Wikitty> restore(String securityToken,
-            WikittyTransaction transaction, List<String> ids) {
-
         List<Wikitty> result = new ArrayList<Wikitty>();
-        boolean txCreated = false;
+        WikittyTransaction transaction = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            if (transaction == null) {
-                transaction = new WikittyTransaction();
-                txCreated = true;
+            if (!transaction.isStarted()) {
                 transaction.begin();
+                txBeginHere = true;
             }
 
             for (String id : ids) {
-                Wikitty w = restore(securityToken, transaction, id);
+                Wikitty w = restore(securityToken, id);
                 // on l'ajoutde tout le temps, meme si w est nul lorsqu'il y a
                 // une demande et qu'elle echoue on ajout
                 // bien null, pour qu'il y ait une correspondance 1 pour 1
                 // avec la demande
                 result.add(w);
             }
-            if (txCreated) {
+            if (txBeginHere) {
                 transaction.commit();
             }
             return result;
@@ -528,9 +519,13 @@
         }
     }
 
-    // FIXME poussin 20101029 use WikittyServiceTransaction and remove other transaction
-    protected Wikitty upgradeData(String securityToken,
-            WikittyTransaction transaction, Wikitty wikitty) {
+    /**
+     * Upgrade wikitty but not saved it.
+     * @param securityToken
+     * @param wikitty
+     * @return
+     */
+    protected Wikitty upgradeData(String securityToken, Wikitty wikitty) {
         Wikitty result = wikitty;
 
         Collection<WikittyExtension> extensions = wikitty.getExtensions();
@@ -545,7 +540,7 @@
             String currentExtensionVersion = currentExtension.getVersion();
 
             WikittyExtension lastExtension = restoreExtensionLastVersion(
-                    securityToken, transaction, extensionName);
+                    securityToken, extensionName);
             String lastExtensionVersion = lastExtension.getVersion();
 
             if (log.isDebugEnabled()) {
@@ -567,7 +562,7 @@
                 String nextExtensionId =
                         WikittyExtension.computeId(extensionName, nextExtensionVersion);
                 WikittyExtension nextExtension = restoreExtension(
-                        securityToken, transaction, nextExtensionId);
+                        securityToken, nextExtensionId);
 
                 if (log.isDebugEnabled()) {
                     log.debug("currentExtensionVersion="  + currentExtensionVersion);
@@ -589,85 +584,93 @@
         return result;
     }
 
-    protected WikittyEvent delete(String securityToken, WikittyTransaction transaction,
+    @Override
+    public WikittyEvent delete(String securityToken,
             Collection<String> ids) throws WikittyException {
-        // work only on valid id
-        Collection<Wikitty> storedWikitties = new LinkedHashSet<Wikitty>();
-        // copy ids because we can remove some element, and modify it
-        // use set to prevent id duplication and preformance (contains method call)
-        Set<String> idSet = new LinkedHashSet<String>(ids);
-        for (Iterator<String> i = idSet.iterator(); i.hasNext();) {
-            String id = i.next();
-            // test if wikitty exists
-            if (!getWikittyStorage().exists(transaction, id)) {
-                // don't exist, remove this id in id list
-                i.remove();
-                // go to the next id, because this id doesn't exist and can't
-                // be used in tree
-                continue;
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
+        try {
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
             }
-            if (getWikittyStorage().isDeleted(transaction, id)) {
-                // already deleted, remove this id in id list
-                i.remove();
-                // go to the next id, because this id already deleted and can't
-                // be used in tree
-                continue;
-            }
 
-            // Store node with have deleted node as parent
-            Criteria criteria =
-                    Search.query().eq(WikittyTreeNode.FQ_FIELD_WIKITTYTREENODE_PARENT, id).criteria();
-            List<String> wikittyNodesId = findAllByCriteria(
-                    securityToken, transaction, criteria).getAll();
-            for (String wikittyNodeId : wikittyNodesId) {
-                if(!idSet.contains(wikittyNodeId)) {
-                    Wikitty treeNode = restore(
-                            securityToken, transaction, wikittyNodeId);
-                    WikittyTreeNodeHelper.setParent(treeNode, null);
-                    storedWikitties.add(treeNode);
+            // work only on valid id
+            Collection<Wikitty> storedWikitties = new LinkedHashSet<Wikitty>();
+            // copy ids because we can remove some element, and modify it
+            // use set to prevent id duplication and preformance (contains method call)
+            Set<String> idSet = new LinkedHashSet<String>(ids);
+            for (Iterator<String> i = idSet.iterator(); i.hasNext();) {
+                String id = i.next();
+                // test if wikitty exists
+                if (!getWikittyStorage().exists(tx, id)) {
+                    // don't exist, remove this id in id list
+                    i.remove();
+                    // go to the next id, because this id doesn't exist and can't
+                    // be used in tree
+                    continue;
                 }
-            }
+                if (getWikittyStorage().isDeleted(tx, id)) {
+                    // already deleted, remove this id in id list
+                    i.remove();
+                    // go to the next id, because this id already deleted and can't
+                    // be used in tree
+                    continue;
+                }
 
-            // Store node with have deleted child
-            criteria = Search.query().eq(WikittyTreeNode.FQ_FIELD_WIKITTYTREENODE_ATTACHMENT, id).criteria();
-            wikittyNodesId = findAllByCriteria(
-                    securityToken, transaction, criteria).getAll();
-            for (String wikittyNodeId : wikittyNodesId) {
-                if(!idSet.contains(wikittyNodeId)) {
-                    Wikitty treeNode = restore(
-                            securityToken, transaction, wikittyNodeId);
-                    WikittyTreeNodeHelper.removeAttachment(treeNode, id);
-                    storedWikitties.add(treeNode);
+                // Store node with have deleted node as parent
+                Criteria criteria =
+                        Search.query().eq(WikittyTreeNode.
+                        FQ_FIELD_WIKITTYTREENODE_PARENT, id).criteria();
+                List<String> wikittyNodesId = findAllByCriteria(
+                        securityToken, criteria).getAll();
+                for (String wikittyNodeId : wikittyNodesId) {
+                    if (!idSet.contains(wikittyNodeId)) {
+                        Wikitty treeNode = restore(
+                                securityToken, wikittyNodeId);
+                        WikittyTreeNodeHelper.setParent(treeNode, null);
+                        storedWikitties.add(treeNode);
+                    }
                 }
+
+                // Store node with have deleted child
+                criteria = Search.query().eq(WikittyTreeNode.
+                        FQ_FIELD_WIKITTYTREENODE_ATTACHMENT, id).criteria();
+                wikittyNodesId = findAllByCriteria(
+                        securityToken, criteria).getAll();
+                for (String wikittyNodeId : wikittyNodesId) {
+                    if (!idSet.contains(wikittyNodeId)) {
+                        Wikitty treeNode = restore(
+                                securityToken, wikittyNodeId);
+                        WikittyTreeNodeHelper.removeAttachment(treeNode, id);
+                        storedWikitties.add(treeNode);
+                    }
+                }
             }
-        }
 
-        WikittyEvent eventDelete =
-                getWikittyStorage().delete(transaction, idSet);
-        getSearchEngin().delete(transaction, idSet);
+            WikittyEvent eventDelete =
+                    getWikittyStorage().delete(tx, idSet);
+            getSearchEngin().delete(tx, idSet);
 
-        WikittyEvent eventStore =
-                store(securityToken, transaction, storedWikitties, false);
-    
-        WikittyEvent result = new WikittyEvent(this);
-        result.add(eventDelete);
-        result.add(eventStore);
-        
-        return result;
-    }
+            WikittyEvent eventStore = store(securityToken, storedWikitties, false);
 
-    @Override
-    public WikittyEvent delete(String securityToken, Collection<String> ids){
-        WikittyTransaction transaction = new WikittyTransaction();
-        try {
-            transaction.begin();
-            
-            WikittyEvent result = delete(securityToken, transaction, ids);
+            WikittyEvent result = new WikittyEvent(this);
+            result.add(eventDelete);
+            result.add(eventStore);
 
-            transaction.commit();
+            if (txBeginHere) {
+                tx.commit();
+            }
             return result;
+        } catch (WikittyException ex) {
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
+            throw ex;
         } catch (Exception eee) {
-            transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
             throw new WikittyException("Can't delete wikitty", eee);
         }
     }
@@ -678,71 +681,68 @@
      */
     @Override
     public WikittyEvent clear(String securityToken) {
-        WikittyTransaction transaction = new WikittyTransaction();
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            transaction.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
+            }
 
-            
-            WikittyEvent result = clear(securityToken, transaction);
+            getSearchEngin().clear(tx);
+            WikittyEvent eventWik = getWikittyStorage().clear(tx);
+            WikittyEvent eventExt = getExtensionStorage().clear(tx);
 
-            transaction.commit();
+            WikittyEvent result = new WikittyEvent(this);
+            result.add(eventWik);
+            result.add(eventExt);
+
+            if (txBeginHere) {
+                tx.commit();
+            }
             return result;
+        } catch (WikittyException ex) {
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
+            throw ex;
         } catch (Exception eee) {
-            transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
             throw new WikittyException("Can't clear all data", eee);
         }
     }
 
     /**
-     * Use with caution : It will delete ALL indexes from search engine !
-     * This operation should be disabled in production environment.
-     */
-    protected WikittyEvent clear(String securityToken, WikittyTransaction tx) {
-        getSearchEngin().clear(tx);
-        WikittyEvent eventWik = getWikittyStorage().clear(tx);
-        WikittyEvent eventExt = getExtensionStorage().clear(tx);
-
-        WikittyEvent result = new WikittyEvent(this);
-        result.add(eventWik);
-        result.add(eventExt);
-        return result;
-    }
-
-    /**
      * Assume that this PagedResult contains wikitty id as result and
      * return new PagedResult with Wikitty instance
      */
     @Override
     public PagedResult<String> findAllByCriteria(
             String securityToken, Criteria criteria) {
-        PagedResult<String> result = findAllByCriteria(securityToken, null, criteria);
-        return result;
-    }
-
-    protected PagedResult<String> findAllByCriteria(String securityToken,
-            WikittyTransaction transaction, Criteria criteria) {
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            boolean txCreated = false;
-            if (transaction == null) {
-                transaction = new WikittyTransaction();
-                txCreated = true;
-                transaction.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
             }
 
             PagedResult<String> result =
-                    getSearchEngin().findAllByCriteria(transaction, criteria);
-            if (txCreated) {
-                transaction.commit();
+                    getSearchEngin().findAllByCriteria(tx, criteria);
+            if (txBeginHere) {
+                tx.commit();
             }
             return result;
         } catch (WikittyException ex) {
-            if (transaction != null) {
-                transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
             }
             throw ex;
         } catch (Exception eee) {
-            if (transaction != null) {
-                transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
             }
             throw new WikittyException("Error during find", eee);
         }
@@ -750,124 +750,128 @@
 
     @Override
     public Wikitty findByCriteria(String securityToken, Criteria criteria) {
-        Wikitty result = findByCriteria(securityToken, null, criteria);
-        return result;
-    }
-
-    protected Wikitty findByCriteria(String securityToken,
-            WikittyTransaction transaction, Criteria criteria) {
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            boolean txCreated = false;
-            if (transaction == null) {
-                transaction = new WikittyTransaction();
-                txCreated = true;
-                transaction.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
             }
 
             criteria.setFirstIndex(0).setEndIndex(1);
             PagedResult<String> pages = findAllByCriteria(
-                    securityToken, transaction, criteria);
+                    securityToken, criteria);
 
             Wikitty result = null;
             if (pages.size() > 0) {
                 String id = pages.getFirst();
-                result = restore(securityToken, transaction, id);
+                result = restore(securityToken, id);
             }
 
-            if (txCreated) {
-                transaction.commit();
+            if (txBeginHere) {
+                tx.commit();
             }
             return result;
         } catch (WikittyException ex) {
-            if (transaction != null) {
-                transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
             }
             throw ex;
         } catch (Exception eee) {
-            if (transaction != null) {
-                transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
             }
             throw new WikittyException("Error during find", eee);
         }
     }
 
-    protected WikittyTree restoreTree(String securityToken,
-            WikittyTransaction transaction, String wikittyId) {
-        Wikitty w = restore(securityToken, transaction, wikittyId);
-        if(w == null) {
-            return null;
-        }
+    @Override
+    public WikittyTree restoreTree(String securityToken, String wikittyId) {
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
+        try {
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
+            }
 
-        if ( !w.hasExtension(WikittyTreeNode.EXT_WIKITTYTREENODE) ) {
-            throw new WikittyException(String.format(
-                    "Wikitty '%s' do not handle extension %s",
-                    wikittyId, WikittyTreeNode.EXT_WIKITTYTREENODE ));
-        }
-        WikittyTree tree = new WikittyTree();
-        WikittyTreeNode node = new WikittyTreeNodeImpl(w);
-        tree.setNode(node);
+            Wikitty w = restore(securityToken, wikittyId);
+            if (w == null) {
+                if (txBeginHere) {
+                    tx.commit();
+                }
+                return null;
+            }
 
-        WikittyTreeNodeImpl exempleNode = new WikittyTreeNodeImpl();
-        exempleNode.setParent(wikittyId);
+            if (!w.hasExtension(WikittyTreeNode.EXT_WIKITTYTREENODE)) {
+                throw new WikittyException(String.format(
+                        "Wikitty '%s' do not handle extension %s",
+                        wikittyId, WikittyTreeNode.EXT_WIKITTYTREENODE));
+            }
+            WikittyTree tree = new WikittyTree();
+            WikittyTreeNode node = new WikittyTreeNodeImpl(w);
+            tree.setNode(node);
 
-        Criteria criteria = Search.query(exempleNode.getWikitty()).criteria()
-                .setFirstIndex(0).setEndIndex(Criteria.ALL_ELEMENTS);
-        PagedResult<String> childNodesId = findAllByCriteria(
-                securityToken, transaction, criteria);
-        for (String childNodeId : childNodesId.getAll()) {
-            tree.addChild(restoreTree(securityToken, transaction, childNodeId));
-        }
+            WikittyTreeNodeImpl exempleNode = new WikittyTreeNodeImpl();
+            exempleNode.setParent(wikittyId);
 
-        return tree;
-    }
+            Criteria criteria = Search.query(exempleNode.getWikitty())
+                    .criteria().setFirstIndex(0).setEndIndex(Criteria.ALL_ELEMENTS);
+            PagedResult<String> childNodesId = findAllByCriteria(
+                    securityToken, criteria);
+            for (String childNodeId : childNodesId.getAll()) {
+                tree.addChild(restoreTree(securityToken, childNodeId));
+            }
 
-    @Override
-    public WikittyTree restoreTree(String securityToken, String wikittyId) {
-        WikittyTransaction transaction = new WikittyTransaction();
-        try {
-            transaction.begin();
-            
-            WikittyTree tree = restoreTree(securityToken, transaction, wikittyId);
-
-            transaction.commit();
+            if(txBeginHere) {
+                tx.commit();
+            }
             return tree;
+        } catch (WikittyException ex) {
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
+            throw ex;
         } catch (Exception eee) {
-            transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
             throw new WikittyException("Can't restore tree", eee);
         }
     }
 
     @Override
     public WikittyEvent deleteTree(String securityToken, String thesaurusId) {
-        WikittyTransaction transaction = new WikittyTransaction();
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            transaction.begin();
-            
-            WikittyEvent result = deleteTree(securityToken, transaction, thesaurusId);
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
+            }
 
-            transaction.commit();
+            List<String> allTreeNodeId = getRecursiveTreeNodeId(
+                    securityToken, thesaurusId);
+            WikittyEvent result = delete(securityToken, allTreeNodeId);
+           
+            if (txBeginHere) {
+                tx.commit();
+            }
             return result;
+        } catch (WikittyException ex) {
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
+            throw ex;
         } catch (Exception eee) {
-            transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
             throw new WikittyException("Can't delete tree", eee);
         }
     }
 
     /**
-     * Delete specified treenode and sub treenode.
-     * 
-     * @param securityToken security token
-     * @param transaction transaction
-     * @param treeNodeId thesaurusId to delete
-     * @return all id of delete nodes
-     */
-    protected WikittyEvent deleteTree(String securityToken, WikittyTransaction transaction, String treeNodeId) {
-        List<String> allTreeNodeId = getRecursiveTreeNodeId(securityToken, transaction, treeNodeId);
-        WikittyEvent result = delete(securityToken, transaction, allTreeNodeId);
-        return result;
-    }
-
-    /**
      * Get recursive id of tree node children of {@code treeNodeId}.
      * 
      * @param securityToken security token
@@ -875,17 +879,16 @@
      * @param treeNodeId tree node id
      * @return all id of {@code treeNodeId}'s children 
      */
-    protected List<String> getRecursiveTreeNodeId(String securityToken, WikittyTransaction transaction, String treeNodeId) {
-
+    protected List<String> getRecursiveTreeNodeId(String securityToken, String treeNodeId) {
         Search search = Search.query();
         search = search.eq(WikittyTreeNode.FQ_FIELD_WIKITTYTREENODE_PARENT, treeNodeId);
         Criteria criteria = search.criteria();
 
-        PagedResult<String> childTreeNodeIds = findAllByCriteria(securityToken, transaction, criteria);
+        PagedResult<String> childTreeNodeIds = findAllByCriteria(securityToken, criteria);
         List<String> treeNodeIds = new ArrayList<String>();
         treeNodeIds.add(treeNodeId);
         for (String childTreeNodeId : childTreeNodeIds.getAll()) {
-            List<String> subTreeNodeIds = getRecursiveTreeNodeId(securityToken, transaction, childTreeNodeId);
+            List<String> subTreeNodeIds = getRecursiveTreeNodeId(securityToken, childTreeNodeId);
             treeNodeIds.addAll(subTreeNodeIds);
         }
         return treeNodeIds;
@@ -894,13 +897,19 @@
     @Override
     public Map.Entry<WikittyTreeNode, Integer> restoreNode(String securityToken,
             String wikittyId, Criteria filter) {
-        WikittyTransaction transaction = new WikittyTransaction();
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            transaction.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
+            }
 
-            Wikitty w = restore(securityToken, transaction, wikittyId);
+            Wikitty w = restore(securityToken, wikittyId);
             if(w == null) {
-                transaction.commit();
+                if (txBeginHere) {
+                    tx.commit();
+                }
                 return null;
             }
 
@@ -911,15 +920,24 @@
             }
 
             WikittyTreeNode node = new WikittyTreeNodeImpl(w);
-            Integer count = getSearchEngin().findNodeCount(transaction, w, filter);
+            Integer count = getSearchEngin().findNodeCount(tx, w, filter);
 
             HashMap.SimpleEntry<WikittyTreeNode, Integer> result =
                     new SimpleEntry<WikittyTreeNode, Integer>(node, count);
 
-            transaction.commit();
+            if (txBeginHere) {
+                tx.commit();
+            }
             return result;
+        } catch (WikittyException ex) {
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
+            throw ex;
         } catch (Exception eee) {
-            transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
             throw new WikittyException("Can't restore node", eee);
         }
     }
@@ -927,13 +945,19 @@
     @Override
     public Map<WikittyTreeNode, Integer> restoreChildren(String securityToken,
             String wikittyId, Criteria filter) {
-        WikittyTransaction transaction = new WikittyTransaction();
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            transaction.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
+            }
 
-            Wikitty w = restore(securityToken, transaction, wikittyId);
+            Wikitty w = restore(securityToken, wikittyId);
             if(w == null) {
-                transaction.commit();
+                if (txBeginHere) {
+                    tx.commit();
+                }
                 return null;
             }
 
@@ -946,22 +970,31 @@
             Map<WikittyTreeNode, Integer> result = new LinkedHashMap<WikittyTreeNode, Integer>();
 
             Map<String, Integer> search = getSearchEngin().findAllChildrenCount(
-                    transaction, w, filter);
+                    tx, w, filter);
             Set<Entry<String, Integer>> children = search.entrySet();
             for (Entry<String, Integer> child : children) {
                 Integer count = child.getValue();
 
                 String id = child.getKey();
-                Wikitty wikitty = restore(securityToken, transaction, id);
+                Wikitty wikitty = restore(securityToken, id);
                 WikittyTreeNode node = new WikittyTreeNodeImpl(wikitty);
 
                 result.put(node, count);
             }
 
-            transaction.commit();
+            if (txBeginHere) {
+                tx.commit();
+            }
             return result;
+        } catch (WikittyException ex) {
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
+            throw ex;
         } catch (Exception eee) {
-            transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
             throw new WikittyException("Can't restore children", eee);
         }
     }
@@ -972,25 +1005,42 @@
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
+    /**
+     * This method do some commit during execution. Transaction must be not
+     * started when we call it.
+     * @param securityToken
+     */
     @Override
     public void syncEngin(final String securityToken) {
-        final WikittyTransaction transaction = new WikittyTransaction();
+        final WikittyTransaction tx = WikittyTransaction.get();
+        if (tx.isStarted()) {
+            throw new WikittyException("Transaction must be not started for syncEngin method");
+        }
+
+        boolean txBeginHere = false;
         try {
             final int numberForCommit = 1000;
             final WikittySearchEngin searchEngin = getSearchEngin();
             final List<Wikitty> wikitties = new ArrayList<Wikitty>(numberForCommit);
 
-            transaction.begin();
-            searchEngin.clear(transaction);
-            transaction.commit();
-            transaction.begin();
-
-            getWikittyStorage().scanWikitties(transaction, new WikittyStorage.Scanner() {
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
+            }
+            searchEngin.clear(tx);
+            if (txBeginHere) {
+                tx.commit();
+            }
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
+            }
+            getWikittyStorage().scanWikitties(tx, new WikittyStorage.Scanner() {
                 int count = 0;
 
                 @Override
                 public void scan(String wikittyId) {
-                    Wikitty wikitty = restore(securityToken, transaction, wikittyId);
+                    Wikitty wikitty = restore(securityToken, wikittyId);
                     Date deleteDate = wikitty.getDeleteDate();
                     if(deleteDate == null) {
                         count ++;
@@ -998,22 +1048,31 @@
 
                         if(count == numberForCommit) {
                             // Reindex
-                            searchEngin.store(transaction, wikitties);
-                            transaction.commit();
+                            searchEngin.store(tx, wikitties);
+                            tx.commit();
                             // Reinit
                             count = 0;
                             wikitties.clear();
-                            transaction.begin();
+                            tx.begin();
                         }
                     }
                 }
             });
 
             // Last wikitties
-            searchEngin.store(transaction, wikitties);
-            transaction.commit();
+            searchEngin.store(tx, wikitties);
+            if (txBeginHere) {
+                tx.commit();
+            }
+        } catch (WikittyException ex) {
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
+            throw ex;
         } catch (Exception eee) {
-            transaction.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
             throw new WikittyException("Can't sync searchable index with data", eee);
         }
     }
@@ -1084,35 +1143,48 @@
             }
         }
 
-        WikittyTransaction tx = new WikittyTransaction();
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            tx.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
+            }
 
             WikittyEvent result = new WikittyEvent(this);
             if (mustClear) {
-                WikittyEvent eventClear = clear(securityToken, tx);
+                WikittyEvent eventClear = clear(securityToken);
                 result.add(eventClear);
             }
             WikittyEvent eventStoreExtension =
-                    storeExtension(securityToken, tx, toAddExt);
+                    storeExtension(securityToken, toAddExt);
             result.add(eventStoreExtension);
 
             WikittyEvent eventDeleteExtension =
-                    deleteExtension(securityToken, tx, toDeleteExt);
+                    deleteExtension(securityToken, toDeleteExt);
             result.add(eventDeleteExtension);
 
             WikittyEvent eventStoreWikitty =
-                    store(securityToken, tx, toAddWikitty.values(), force);
+                    store(securityToken, toAddWikitty.values(), force);
             result.add(eventStoreWikitty);
 
             WikittyEvent eventDeleteWikitty =
-                    delete(securityToken, tx, toRemoveWikitty.keySet());
+                    delete(securityToken, toRemoveWikitty.keySet());
             result.add(eventDeleteWikitty);
 
-            tx.commit();
+            if(txBeginHere) {
+                tx.commit();
+            }
             return result;
+        } catch (WikittyException ex) {
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
+            throw ex;
         } catch (Exception eee) {
-            tx.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
             throw new WikittyException("Can't replay data", eee);
         }
 
@@ -1120,28 +1192,57 @@
 
     @Override
     public boolean exists(String securityToken, String wikittyId) {
-        WikittyTransaction tx = new WikittyTransaction();
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            tx.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
+            }
+
             boolean result = getWikittyStorage().exists(null, wikittyId);
-            tx.commit();
+
+            if (txBeginHere) {
+                tx.commit();
+            }
             return result;
+        } catch (WikittyException ex) {
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
+            throw ex;
         } catch (Exception eee) {
-            tx.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
             throw new WikittyException("Can't test existance", eee);
         }
     }
 
     @Override
     public boolean isDeleted(String securityToken, String wikittyId) {
-        WikittyTransaction tx = new WikittyTransaction();
+        WikittyTransaction tx = WikittyTransaction.get();
+        boolean txBeginHere = false;
         try {
-            tx.begin();
+            if (!tx.isStarted()) {
+                tx.begin();
+                txBeginHere = true;
+            }
+
             boolean result = getWikittyStorage().isDeleted(tx, wikittyId);
-            tx.commit();
+            if (txBeginHere) {
+                tx.commit();
+            }
             return result;
+        } catch (WikittyException ex) {
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
+            throw ex;
         } catch (Exception eee) {
-            tx.rollback();
+            if (tx != null && tx.isStarted()) {
+                tx.rollback();
+            }
             throw new WikittyException("Can't test existance", eee);
         }
     }

Modified: trunk/wikitty-api/src/main/java/org/nuiton/wikitty/services/WikittyTransaction.java
===================================================================
--- trunk/wikitty-api/src/main/java/org/nuiton/wikitty/services/WikittyTransaction.java	2010-12-01 14:37:43 UTC (rev 547)
+++ trunk/wikitty-api/src/main/java/org/nuiton/wikitty/services/WikittyTransaction.java	2010-12-01 15:32:39 UTC (rev 548)
@@ -35,6 +35,8 @@
 
 /***
  * Manage JTA transaction. You can store some information during execution.
+ * Each thread have only one transaction. To get current transaction use
+ * {@link WikittyTransaction#get()} method
  */
 public class WikittyTransaction {
 
@@ -44,10 +46,31 @@
     /** permet d'attacher n'importe quoi a une transaction */
     protected Map<Object, Object> tagValues;
 
-    public WikittyTransaction() {
+    /** if true begin has been called for this transaction */
+    protected boolean started = false;
+
+    private static ThreadLocal<WikittyTransaction> wikittyTransaction =
+            new ThreadLocal<WikittyTransaction>() {
+        @Override
+        protected synchronized WikittyTransaction initialValue() {
+            return new WikittyTransaction();
+        }
+    };
+
+    private WikittyTransaction() {
         tagValues = new HashMap<Object, Object>();
     }
 
+    /**
+     * return current transaction used by current thread. If no transaction
+     * existe, create new one.
+     * YOU MUST COMMIT OR ROLLBACK TRANSACTION AFTER USE
+     * @return
+     */
+    static public WikittyTransaction get() {
+        return wikittyTransaction.get();
+    }
+
     public Object getTagValue(Object tag) {
         return tagValues.get(tag);
     }
@@ -56,6 +79,14 @@
         tagValues.put(tag, value);
     }
 
+    public boolean isStarted() {
+        return started;
+    }
+
+    protected void setStarted(boolean started) {
+        this.started = started;
+    }
+
     public UserTransaction getUserTransaction() {
         return com.arjuna.ats.jta.UserTransaction.userTransaction();
     }
@@ -65,6 +96,9 @@
     }
 
     public void begin() {
+        if (isStarted()) {
+            throw new WikittyException("Transaction is already started");
+        }
         UserTransaction userTransaction = getUserTransaction();
         try {
             if (log.isDebugEnabled()) {
@@ -72,6 +106,7 @@
             }
             userTransaction.setTransactionTimeout(3600); // FIXME: jru 20100115 error in service if call during lot of times
             userTransaction.begin();
+            setStarted(true);
         } catch (Exception eee) {
             throw new WikittyException("Error on begin JTA transaction", eee);
         }
@@ -84,6 +119,7 @@
                 log.debug("Commit transaction");
             }
             userTransaction.commit();
+            setStarted(false);
         } catch (Exception eee) {
             throw new WikittyException("Error on commit JTA transaction", eee);
         }
@@ -99,8 +135,10 @@
                 }
                 userTransaction.rollback();
             }
+            setStarted(false);
         } catch (Exception eee) {
             throw new WikittyException("Error on roolback JTA transaction", eee);
         }
     }
+
 }

    

r548 - trunk/wikitty-api/src/main/java/org/nuiton/wikitty/services

bpoussin＠users.nuiton.org

tags

participants (1)