Changeset 5280

Timestamp:

2011-12-19 16:24:00 (17 months ago)

Author:

evert

Message:

Schema Cache:

• Catch any exception when checking the lilyNodes on zookeeper instead of only the NoNodeException?, and log at Debug level.
• Keep track of locally updated FieldTypes? and avoid overwriting them with old data when refreshing the cache. This manifests itself in the rename FieldType? test.

Location:

trunk/cr/repository

Files:

• impl/src/main/java/org/lilyproject/repository/impl/AbstractSchemaCache.java (modified) (2 diffs)
• impl/src/main/java/org/lilyproject/repository/impl/FieldTypesCache.java (modified) (5 diffs)
• test/src/test/java/org/lilyproject/repository/impl/test/SchemaCacheTest.java (modified) (1 diff)

trunk/cr/repository/impl/src/main/java/org/lilyproject/repository/impl/AbstractSchemaCache.java

@@ -47 +47 @@
     private FieldTypes fieldTypesSnapshot;
     private FieldTypesCache fieldTypesCache = new FieldTypesCache();
-    private boolean updatedFieldTypes = false;
+    private volatile boolean updatedFieldTypes = false;
 
     private RecordTypesCache recordTypes = new RecordTypesCache();
@@ -438 +438 @@
                 lilyNodes = zooKeeper.getChildren(LILY_NODES_PATH, watcher);
                 lilyNodesWatcher = watcher;
-            } catch (KeeperException.NoNodeException e) {
+            } catch (KeeperException e) {
+                if (log.isDebugEnabled())
+                    log.debug("Failed getting lilyNodes from Zookeeper", e);
                 // The path does not exist yet.
                 // Set the lilyNodesWatcher to null so that we retry

trunk/cr/repository/impl/src/main/java/org/lilyproject/repository/impl/FieldTypesCache.java

@@ -17 +17 @@
 
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
@@ -42 +44 @@
     // lead to an inconsistent state (two types could get the same name).
     private volatile int count = 0;
+    
+    private ConcurrentHashMap<String, Set<SchemaId>> localUpdateBuckets = new ConcurrentHashMap<String, Set<SchemaId>>();
 
     private Log log = LogFactory.getLog(getClass());
@@ -164 +168 @@
                 monitor.wait();
             }
-            // The nameCache can be made up to date as well since everything is
-            // being updated
-            nameCacheOutOfDate = false;
-            nameCache = new HashMap<QName, FieldType>(fieldTypes.size());
+            nameCacheOutOfDate = true;
             // One would expect that existing buckets need to be cleared first.
             // But since field types cannot be deleted we will just overwrite
             // them.
             for (FieldType fieldType : fieldTypes) {
-                nameCache.put(fieldType.getName(), fieldType);
                 String bucketId = AbstractSchemaCache.encodeHex(fieldType.getId().getBytes());
-                Map<SchemaId, FieldType> bucket = buckets.get(bucketId);
-                if (bucket == null) {
-                    bucket = new ConcurrentHashMap<SchemaId, FieldType>(8, .75f, 1);
-                    buckets.put(bucketId, bucket);
-                }
-                bucket.put(fieldType.getId(), fieldType);
+                // Only update if it was not updated locally
+                // If it was updated locally either this is the refresh of that
+                // update,
+                // or the refresh for this update will follow.
+                if (!removeFromLocalUpdateBucket(fieldType.getId(), bucketId)) {
+                    Map<SchemaId, FieldType> bucket = buckets.get(bucketId);
+                    if (bucket == null) {
+                        bucket = new ConcurrentHashMap<SchemaId, FieldType>(8, .75f, 1);
+                        buckets.put(bucketId, bucket);
+                    }
+                    bucket.put(fieldType.getId(), fieldType);
+                }
             }
         }
@@ -208 +214 @@
             // Fill a the bucket with the new field types
             for (FieldType fieldType : fieldTypes) {
-                bucket.put(fieldType.getId(), fieldType);
+                if (!removeFromLocalUpdateBucket(fieldType.getId(), bucketId)) {
+                    bucket.put(fieldType.getId(), fieldType);
+                }
             }
         }
@@ -236 +244 @@
             }
             bucket.put(id, ftToCache);
+            // Mark that this fieldType is updated locally
+            // and that the next refresh can be ignored
+            // since this refresh can contain an old fieldType
+            addToLocalUpdateBucket(id, bucketId);
         }
         // Decrement the number of buckets that are being updated again.
         decCount();
     }
+
+    // Add the id of a field type that has been updated locally
+    // in a bucket. This field type will be skipped in a next
+    // cache refresh sequence.
+    // This avoids that a locally updated field type will be
+    // overwritten by old data by a cache refresh.
+    private void addToLocalUpdateBucket(SchemaId id, String bucketId) {
+        Set<SchemaId> localUpdateBucket = localUpdateBuckets.get(bucketId);
+        if (localUpdateBucket == null) {
+            localUpdateBucket = new HashSet<SchemaId>();
+            localUpdateBuckets.put(bucketId, localUpdateBucket);
+        }
+        localUpdateBucket.add(id);
+    }
+
+    // Check if the field type is present in the local update bucket.
+    // If so, return true and remove it, in which case the refresh
+    // should skip it to avoid replacing the field type with old data.
+    private boolean removeFromLocalUpdateBucket(SchemaId id, String bucketId) {
+        Set<SchemaId> localUpdateBucket = localUpdateBuckets.get(bucketId);
+        if (localUpdateBucket == null) {
+            return false;
+        }
+        return localUpdateBucket.remove(id);
+    }
 }

trunk/cr/repository/test/src/test/java/org/lilyproject/repository/impl/test/SchemaCacheTest.java

@@ -225 +225 @@
         QName ftName = new QName("testRenameFieldType", "f");
         FieldType fieldType = typeManager.fieldTypeBuilder().name(ftName).create();
-        for (int i = 0; i< 10; i++) {
+        for (int i = 0; i < 100; i++) {
             QName newFtName = new QName("testRenameFieldType", "f"+i);
             fieldType.setName(newFtName);