update cache_type default value

hugegraph-core/src/main/java/com/baidu/hugegraph/backend/cache/OffheapCache.java

@@ -111,12 +111,20 @@ protected Object access(Id id) {
     @Override
     protected boolean write(Id id, Object value, long timeOffset) {
         Value serializedValue = new Value(value);
-        int serializedSize = serializedValue.serializedSize();
+        int serializedSize;
+        try {
+            serializedSize = serializedValue.serializedSize();
+        } catch (Throwable e) {
+            // May can't cache value that failed to serialize, like 0x00 byte
+            LOG.warn("Can't cache '{}' due to {}", id, e.toString());
+            return false;
+        }
         if (serializedSize > VALUE_SIZE_TO_SKIP) {
             LOG.info("Skip to cache '{}' due to value size {} > limit {}",
                       id, serializedSize, VALUE_SIZE_TO_SKIP);
             return false;
         }
+
         long expireTime = this.expire();
         boolean success;
         if (expireTime <= 0L) {
@@ -222,10 +230,15 @@ public ByteBuffer asBuffer() {
                 if (this.value instanceof List) {
                     listSize = ((List<?>) this.value).size();
                 }
-                this.svalue = BytesBuffer.allocate(64 * listSize);
-                this.serialize(this.value, this.svalue);
-                this.serializedSize = this.svalue.position();
-                this.svalue.forReadWritten();
+
+                BytesBuffer buffer = BytesBuffer.allocate(64 * listSize);
+
+                // May fail to serialize and throw exception here
+                this.serialize(this.value, buffer);
+
+                this.serializedSize = buffer.position();
+                buffer.forReadWritten();
+                this.svalue = buffer;
             }
             return this.svalue.asByteBuffer();
         }
@@ -339,13 +352,16 @@ private static enum ValueType {
         LIST,
         VERTEX,
         EDGE,
-        BYTES(DataType.BLOB),
+        BOOLEAN(DataType.BOOLEAN),
+        BYTE(DataType.BYTE),
+        BLOB(DataType.BLOB),
         STRING(DataType.TEXT),
         INT(DataType.INT),
         LONG(DataType.LONG),
         FLOAT(DataType.FLOAT),
         DOUBLE(DataType.DOUBLE),
-        DATE(DataType.DATE);
+        DATE(DataType.DATE),
+        UUID(DataType.UUID);
 
         private DataType dataType;
 
@@ -379,7 +395,7 @@ public static ValueType valueOf(Object object) {
                 return ValueType.LIST;
             } else if (HugeVertex.class.isAssignableFrom(clazz)) {
                 return ValueType.VERTEX;
-            } else if (clazz == HugeEdge.class) {
+            } else if (HugeEdge.class.isAssignableFrom(clazz)) {
                 return ValueType.EDGE;
             } else {
                 for (ValueType type : values()) {

hugegraph-core/src/main/java/com/baidu/hugegraph/config/CoreOptions.java

@@ -522,7 +522,7 @@ public static synchronized CoreOptions instance() {
                     "vertex.cache_type",
                     "The type of vertex cache, allowed values are [l1, l2].",
                     allowValues("l1", "l2"),
-                    "l1"
+                    "l2"
             );
 
     public static final ConfigOption<Long> VERTEX_CACHE_CAPACITY =
@@ -546,7 +546,7 @@ public static synchronized CoreOptions instance() {
                     "edge.cache_type",
                     "The type of edge cache, allowed values are [l1, l2].",
                     allowValues("l1", "l2"),
-                    "l1"
+                    "l2"
             );
 
     public static final ConfigOption<Long> EDGE_CACHE_CAPACITY =

hugegraph-dist/src/assembly/static/conf/hugegraph.properties

@@ -5,9 +5,11 @@ gremlin.graph=com.baidu.hugegraph.HugeFactory
 # cache config
 #schema.cache_capacity=100000
 # vertex-cache default is 1000w, 10min expired
+vertex.cache_type=l2
 #vertex.cache_capacity=10000000
 #vertex.cache_expire=600
 # edge-cache default is 100w, 10min expired
+edge.cache_type=l2
 #edge.cache_capacity=1000000
 #edge.cache_expire=600
 

hugegraph-test/src/main/java/com/baidu/hugegraph/unit/cache/CacheTest.java

@@ -24,13 +24,13 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.UUID;
 
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mockito;
 
-import com.baidu.hugegraph.HugeException;
 import com.baidu.hugegraph.HugeGraph;
 import com.baidu.hugegraph.backend.cache.Cache;
 import com.baidu.hugegraph.backend.cache.LevelCache;
@@ -41,6 +41,7 @@
 import com.baidu.hugegraph.testutil.Assert;
 import com.baidu.hugegraph.testutil.Whitebox;
 import com.baidu.hugegraph.unit.BaseUnitTest;
+import com.baidu.hugegraph.util.Blob;
 import com.baidu.hugegraph.util.Bytes;
 
 import jersey.repackaged.com.google.common.collect.ImmutableList;
@@ -183,25 +184,22 @@ protected HugeGraph graph() {
             return this.graph;
         }
 
-        @Override
         @Test
-        public void testUpdateAndGetWithDataType() {
+        public void testUpdateAndGetWithInvalidDataType() {
             Cache<Id, Object> cache = newCache();
             Id id = IdGenerator.of("1");
 
-            Assert.assertThrows(HugeException.class, () -> {
-                cache.update(id, 'c');
-            }, e -> {
-                Assert.assertContains("Unsupported type of serialize value",
-                                      e.getMessage());
-            });
+            cache.update(id, 'c');
+            Assert.assertNull(cache.get(id));
 
-            Assert.assertThrows(HugeException.class, () -> {
-                cache.update(id, true);
-            }, e -> {
-                Assert.assertContains("Unsupported type of serialize value",
-                                      e.getMessage());
-            });
+            cache.update(id, new Object());
+            Assert.assertNull(cache.get(id));
+
+            cache.update(id, new byte[]{1});
+            Assert.assertNull(cache.get(id));
+
+            cache.update(id, "string");
+            Assert.assertEquals("string", cache.get(id));
         }
     }
 
@@ -218,6 +216,28 @@ protected Cache<Id, Object> newCache(long capacity) {
             OffheapCache l2cache = (OffheapCache) super.newCache(capacity);
             return new LevelCache(l1cache, l2cache);
         }
+
+        @Test
+        @Override
+        public void testUpdateAndGetWithInvalidDataType() {
+            // LevelCache includes level-1 RamCache, which can cache any object
+            Cache<Id, Object> cache = newCache();
+            Id id = IdGenerator.of("1");
+
+            cache.update(id, 'c');
+            Assert.assertEquals('c', cache.get(id));
+
+            Object obj = new Object();
+            cache.update(id, obj);
+            Assert.assertEquals(obj, cache.get(id));
+
+            byte[] bytes = new byte[]{1};
+            cache.update(id, bytes);
+            Assert.assertArrayEquals(bytes, (byte[]) cache.get(id));
+
+            cache.update(id, "string");
+            Assert.assertEquals("string", cache.get(id));
+        }
     }
 
     @Test
@@ -240,15 +260,26 @@ public void testUpdateAndGetWithDataType() {
         Assert.assertNull(cache.get(id));
 
         /*
+         * BOOLEAN
+         * BYTE
          * STRING
          * INT
          * LONG
          * FLOAT
          * DOUBLE
          * DATE
-         * BYTES
+         * UUID
+         * BLOB
          * LIST
          */
+        cache.update(id, true);
+        Assert.assertEquals(true, cache.get(id));
+        cache.update(id, false);
+        Assert.assertEquals(false, cache.get(id));
+
+        cache.update(id, (byte) 123);
+        Assert.assertEquals((byte) 123, cache.get(id));
+
         cache.update(id, "string");
         Assert.assertEquals("string", cache.get(id));
 
@@ -268,9 +299,13 @@ public void testUpdateAndGetWithDataType() {
         cache.update(id, now);
         Assert.assertEquals(now, cache.get(id));
 
+        UUID uuid = UUID.randomUUID();
+        cache.update(id, uuid);
+        Assert.assertEquals(uuid, cache.get(id));
+
         byte[] bytes = new byte[]{1, 33, 88};
-        cache.update(id, bytes);
-        Assert.assertArrayEquals(bytes, (byte[]) cache.get(id));
+        cache.update(id, Blob.wrap(bytes));
+        Assert.assertEquals(Blob.wrap(bytes), cache.get(id));
 
         List<Integer> list = ImmutableList.of(1, 3, 5);
         cache.update(id, list);