ozeigermann    2004/10/20 01:09:05

  Modified:    src/share/org/apache/slide/store ExtendedStore.java
  Log:
  Added some safety code that tries to invalidate caches when objects that should be 
there vanish or
  objects that should not be there emerge
  
  Revision  Changes    Path
  1.21      +174 -31   
jakarta-slide/src/share/org/apache/slide/store/ExtendedStore.java
  
  Index: ExtendedStore.java
  ===================================================================
  RCS file: 
/home/cvs/jakarta-slide/src/share/org/apache/slide/store/ExtendedStore.java,v
  retrieving revision 1.20
  retrieving revision 1.21
  diff -u -r1.20 -r1.21
  --- ExtendedStore.java        20 Oct 2004 07:22:44 -0000      1.20
  +++ ExtendedStore.java        20 Oct 2004 08:09:05 -0000      1.21
  @@ -533,13 +533,21 @@
                       // FIXME make a copy?! how?
                       return revisionContent;
                   }
  +            } catch (ServiceAccessException sae) {
  +                invalidateCacheUponError(uri);
  +                throw sae;
               } finally {
                   if (isForceStoreEnlistment(uri)) {
                       delist(this);
                   }
               }
           } else {
  -            return super.retrieveRevisionContent(uri, revisionDescriptor);
  +            try {
  +                return super.retrieveRevisionContent(uri, revisionDescriptor);
  +            } catch (ServiceAccessException sae) {
  +                invalidateCacheUponError(uri);
  +                throw sae;
  +            }
           }
       }
   
  @@ -554,8 +562,12 @@
               size = revisionDescriptor.getContentLength();
               contentCache.precache(revisionContent, size);
           }
  -
  -        super.createRevisionContent(uri, revisionDescriptor, revisionContent);
  +        try {
  +            super.createRevisionContent(uri, revisionDescriptor, revisionContent);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
   
           if (contentStore.cacheResults() && contentCache != null) {
               enlist(this);
  @@ -579,8 +591,12 @@
               size = revisionDescriptor.getContentLength();
               contentCache.precache(revisionContent, size);
           }
  -
  -        super.storeRevisionContent(uri, revisionDescriptor, revisionContent);
  +        try {
  +            super.storeRevisionContent(uri, revisionDescriptor, revisionContent);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
   
           if (contentStore.cacheResults() && contentCache != null) {
               enlist(this);
  @@ -604,7 +620,12 @@
                   delist(this);
               }
           }
  -        super.removeRevisionContent(uri, revisionDescriptor);
  +        try {
  +            super.removeRevisionContent(uri, revisionDescriptor);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
       }
   
       //
  @@ -626,18 +647,31 @@
                       objectsCache.put(uri.toString(), objectNode);
                       return objectNode.cloneObject();
                   }
  +            } catch (ServiceAccessException sae) {
  +                invalidateCacheUponError(uri);
  +                throw sae;
               } finally {
                   if (isForceStoreEnlistment(uri)) {
                       delist(this);
                   }
               }
           } else {
  -            return super.retrieveObject(uri);
  +            try {
  +                return super.retrieveObject(uri);
  +            } catch (ServiceAccessException sae) {
  +                invalidateCacheUponError(uri);
  +                throw sae;
  +            }
           }
       }
   
       public void storeObject(Uri uri, ObjectNode object) throws 
ServiceAccessException, ObjectNotFoundException {
  -        super.storeObject(uri, object);
  +        try {
  +            super.storeObject(uri, object);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (nodeStore.cacheResults()) {
               enlist(this);
               try {
  @@ -649,7 +683,12 @@
       }
   
       public void createObject(Uri uri, ObjectNode object) throws 
ServiceAccessException, ObjectAlreadyExistsException {
  -        super.createObject(uri, object);
  +        try {
  +            super.createObject(uri, object);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (nodeStore.cacheResults()) {
               enlist(this);
               try {
  @@ -670,7 +709,12 @@
       }
   
       public void removeObject(Uri uri, ObjectNode object) throws 
ServiceAccessException, ObjectNotFoundException {
  -        super.removeObject(uri, object);
  +        try {
  +            super.removeObject(uri, object);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (nodeStore.cacheResults()) {
               enlist(this);
               try {
  @@ -689,7 +733,12 @@
       }
   
       public void grantPermission(Uri uri, NodePermission permission) throws 
ServiceAccessException {
  -        super.grantPermission(uri, permission);
  +        try {
  +            super.grantPermission(uri, permission);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (securityStore.cacheResults()) {
               enlist(this);
               try {
  @@ -705,7 +754,12 @@
       }
   
       public void revokePermission(Uri uri, NodePermission permission) throws 
ServiceAccessException {
  -        super.revokePermission(uri, permission);
  +        try {
  +            super.revokePermission(uri, permission);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (securityStore.cacheResults()) {
               enlist(this);
               try {
  @@ -722,7 +776,12 @@
       }
   
       public void revokePermissions(Uri uri) throws ServiceAccessException {
  -        super.revokePermissions(uri);
  +        try {
  +            super.revokePermissions(uri);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (securityStore.cacheResults()) {
               enlist(this);
               try {
  @@ -750,12 +809,22 @@
                   }
               }
           } else {
  -            return super.enumeratePermissions(uri);
  +            try {
  +                return super.enumeratePermissions(uri);
  +            } catch (ServiceAccessException sae) {
  +                invalidateCacheUponError(uri);
  +                throw sae;
  +            }
           }
       }
   
       public void putLock(Uri uri, NodeLock lock) throws ServiceAccessException {
  -        super.putLock(uri, lock);
  +        try {
  +            super.putLock(uri, lock);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (lockStore.cacheResults()) {
               enlist(this);
               try {
  @@ -771,7 +840,12 @@
       }
   
       public void renewLock(Uri uri, NodeLock lock) throws ServiceAccessException, 
LockTokenNotFoundException {
  -        super.renewLock(uri, lock);
  +        try {
  +            super.renewLock(uri, lock);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (lockStore.cacheResults()) {
               enlist(this);
               try {
  @@ -793,7 +867,12 @@
       }
   
       public void removeLock(Uri uri, NodeLock lock) throws ServiceAccessException, 
LockTokenNotFoundException {
  -        super.removeLock(uri, lock);
  +        try {
  +            super.removeLock(uri, lock);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (lockStore.cacheResults()) {
               enlist(this);
               try {
  @@ -814,7 +893,12 @@
       }
   
       public void killLock(Uri uri, NodeLock lock) throws ServiceAccessException, 
LockTokenNotFoundException {
  -        super.killLock(uri, lock);
  +        try {
  +            super.killLock(uri, lock);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (lockStore.cacheResults()) {
               enlist(this);
               try {
  @@ -848,7 +932,12 @@
                   }
               }
           } else {
  -            return super.enumerateLocks(uri);
  +            try {
  +                return super.enumerateLocks(uri);
  +            } catch (ServiceAccessException sae) {
  +                invalidateCacheUponError(uri);
  +                throw sae;
  +            }
           }
       }
       
  @@ -868,19 +957,32 @@
                       revisionDescriptors.validate(uri.toString());
                       return revisionDescriptors.cloneObject();
                   }
  +            } catch (ServiceAccessException sae) {
  +                invalidateCacheUponError(uri);
  +                throw sae;
               } finally {
                   if (isForceStoreEnlistment(uri)) {
                       delist(this);
                   }
               }
           } else {
  -            return super.retrieveRevisionDescriptors(uri);
  +            try {
  +                return super.retrieveRevisionDescriptors(uri);
  +            } catch (ServiceAccessException sae) {
  +                invalidateCacheUponError(uri);
  +                throw sae;
  +            }
           }
       }
   
       public void createRevisionDescriptors(Uri uri, NodeRevisionDescriptors 
revisionDescriptors)
           throws ServiceAccessException {
  -        super.createRevisionDescriptors(uri, revisionDescriptors);
  +        try {
  +            super.createRevisionDescriptors(uri, revisionDescriptors);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (revisionDescriptorsStore.cacheResults()) {
               enlist(this);
               try {
  @@ -893,7 +995,12 @@
   
       public void storeRevisionDescriptors(Uri uri, NodeRevisionDescriptors 
revisionDescriptors)
           throws ServiceAccessException, RevisionDescriptorNotFoundException {
  -        super.storeRevisionDescriptors(uri, revisionDescriptors);
  +        try {
  +            super.storeRevisionDescriptors(uri, revisionDescriptors);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (revisionDescriptorsStore.cacheResults()) {
               enlist(this);
               try {
  @@ -913,7 +1020,12 @@
                   delist(this);
               }
           }
  -        super.removeRevisionDescriptors(uri);
  +        try {
  +            super.removeRevisionDescriptors(uri);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
       }
   
       public NodeRevisionDescriptor retrieveRevisionDescriptor(Uri uri, 
NodeRevisionNumber revisionNumber)
  @@ -932,19 +1044,32 @@
                       descriptorCache.put(uri + "-" + revisionNumber, 
revisionDescriptor);
                       return revisionDescriptor.cloneObject();
                   }
  +            } catch (ServiceAccessException sae) {
  +                invalidateCacheUponError(uri);
  +                throw sae;
               } finally {
                   if (isForceStoreEnlistment(uri)) {
                       delist(this);
                   }
               }
           } else {
  -            return super.retrieveRevisionDescriptor(uri, revisionNumber);
  +            try {
  +                return super.retrieveRevisionDescriptor(uri, revisionNumber);
  +            } catch (ServiceAccessException sae) {
  +                invalidateCacheUponError(uri);
  +                throw sae;
  +            }
           }
       }
   
       public void createRevisionDescriptor(Uri uri, NodeRevisionDescriptor 
revisionDescriptor)
           throws ServiceAccessException {
  -        super.createRevisionDescriptor(uri, revisionDescriptor);
  +        try {
  +            super.createRevisionDescriptor(uri, revisionDescriptor);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (revisionDescriptorStore.cacheResults()) {
               enlist(this);
               try {
  @@ -959,7 +1084,12 @@
   
       public void storeRevisionDescriptor(Uri uri, NodeRevisionDescriptor 
revisionDescriptor)
           throws ServiceAccessException, RevisionDescriptorNotFoundException {
  -        super.storeRevisionDescriptor(uri, revisionDescriptor);
  +        try {
  +            super.storeRevisionDescriptor(uri, revisionDescriptor);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (revisionDescriptorStore.cacheResults()) {
               enlist(this);
               try {
  @@ -972,7 +1102,12 @@
       }
   
       public void removeRevisionDescriptor(Uri uri, NodeRevisionNumber number) throws 
ServiceAccessException {
  -        super.removeRevisionDescriptor(uri, number);
  +        try {
  +            super.removeRevisionDescriptor(uri, number);
  +        } catch (ServiceAccessException sae) {
  +            invalidateCacheUponError(uri);
  +            throw sae;
  +        }
           if (revisionDescriptorStore.cacheResults()) {
               enlist(this);
               try {
  @@ -1201,6 +1336,14 @@
           throw re;
       }
   
  +    protected void invalidateCacheUponError(Uri uri) {
  +        // this might indicate the physical store has been changed from other 
sources than Slide
  +        // and there no longer is an object at this uri
  +        // so invalidate caches to at least display this in the next request
  +        removeObjectHierachyFromCache(uri.getParentUri());
  +    }
  +
  +    
       protected class TxCacheWrapper implements ObjectCache {
   
           private TxLRUObjectCache txCache;
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]

Reply via email to