ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From voze...@apache.org
Subject [02/50] ignite git commit: Storing binary metadata in FS
Date Tue, 04 Jul 2017 10:02:08 GMT
Storing binary metadata in FS


Project: http://git-wip-us.apache.org/repos/asf/ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/ignite/commit/92f66b23
Tree: http://git-wip-us.apache.org/repos/asf/ignite/tree/92f66b23
Diff: http://git-wip-us.apache.org/repos/asf/ignite/diff/92f66b23

Branch: refs/heads/master
Commit: 92f66b23e4beb613b7dead87111ccc54aef8bf22
Parents: 94fd731
Author: Sergey Chugunov <sergey.chugunov@gmail.com>
Authored: Fri Jun 23 11:24:52 2017 +0300
Committer: Sergey Chugunov <sergey.chugunov@gmail.com>
Committed: Fri Jun 23 11:24:52 2017 +0300

----------------------------------------------------------------------
 .../discovery/GridDiscoveryManager.java         |   2 +-
 .../cache/binary/BinaryMetadataFileStore.java   | 114 ++++
 .../cache/binary/BinaryMetadataTransport.java   |  15 +-
 .../binary/CacheObjectBinaryProcessorImpl.java  |  14 +-
 ...tePdsBinaryMetadataOnClusterRestartTest.java | 514 +++++++++++++++++++
 .../testframework/junits/GridAbstractTest.java  |   1 +
 .../IgnitePdsWithIndexingCoreTestSuite.java     |   3 +
 7 files changed, 659 insertions(+), 4 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/ignite/blob/92f66b23/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java
b/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java
index de8daa7..c38e37a 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java
@@ -1947,7 +1947,7 @@ public class GridDiscoveryManager extends GridManagerAdapter<DiscoverySpi>
{
                 inject();
             }
             catch (IgniteCheckedException e) {
-                throw new IgniteException("Failed to init consisten ID.", e);
+                throw new IgniteException("Failed to init consistent ID.", e);
             }
 
             consistentId = getSpi().consistentId();

http://git-wip-us.apache.org/repos/asf/ignite/blob/92f66b23/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/binary/BinaryMetadataFileStore.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/binary/BinaryMetadataFileStore.java
b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/binary/BinaryMetadataFileStore.java
new file mode 100644
index 0000000..e682593
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/binary/BinaryMetadataFileStore.java
@@ -0,0 +1,114 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.ignite.internal.processors.cache.binary;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.util.concurrent.ConcurrentMap;
+import org.apache.ignite.IgniteCheckedException;
+import org.apache.ignite.IgniteLogger;
+import org.apache.ignite.internal.GridKernalContext;
+import org.apache.ignite.internal.binary.BinaryMetadata;
+import org.apache.ignite.internal.util.typedef.internal.U;
+
+/**
+ * Class handles saving/restoring binary metadata to/from disk.
+ *
+ * Current implementation needs to be rewritten as it issues IO operations from discovery
thread
+ * which may lead to segmentation of nodes from cluster.
+ */
+class BinaryMetadataFileStore {
+    /** */
+    private File workDir;
+
+    /** */
+    private final ConcurrentMap<Integer, BinaryMetadataHolder> metadataLocCache;
+
+    /** */
+    private final GridKernalContext ctx;
+
+    /** */
+    private final IgniteLogger log;
+
+    /**
+     * @param metadataLocCache Metadata locale cache.
+     * @param ctx Context.
+     * @param log Logger.
+     */
+    BinaryMetadataFileStore(ConcurrentMap<Integer, BinaryMetadataHolder> metadataLocCache,
GridKernalContext ctx, IgniteLogger log) throws IgniteCheckedException {
+        this.metadataLocCache = metadataLocCache;
+        this.ctx = ctx;
+        this.log = log;
+
+        if (!ctx.config().isPersistentStoreEnabled())
+            return;
+
+        String consId = U.maskForFileName(ctx.discovery().consistentId().toString());
+
+        workDir = new File(U.resolveWorkDirectory(
+            ctx.config().getWorkDirectory(),
+            "binary_meta",
+            false
+        ),
+            consId);
+
+        U.ensureDirectory(workDir, "directory for serialized binary metadata", log);
+    }
+
+    /**
+     * @param binMeta Binary metadata to be written to disk.
+     */
+    void saveMetadata(BinaryMetadata binMeta) {
+        if (!ctx.config().isPersistentStoreEnabled())
+            return;
+
+        try {
+            File file = new File(workDir, Integer.toString(binMeta.typeId()) + ".bin");
+
+            try(FileOutputStream out = new FileOutputStream(file, false)) {
+                byte[] marshalled = U.marshal(ctx, binMeta);
+
+                out.write(marshalled);
+            }
+        }
+        catch (Exception e) {
+            U.warn(log, "Failed to save metadata for typeId: " + binMeta.typeId() +
+                "; exception was thrown: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Restores metadata on startup of {@link CacheObjectBinaryProcessorImpl} but before
starting discovery.
+     */
+    void restoreMetadata() {
+        if (!ctx.config().isPersistentStoreEnabled())
+            return;
+
+        for (File file : workDir.listFiles()) {
+            try (FileInputStream in = new FileInputStream(file)) {
+                BinaryMetadata meta = U.unmarshal(ctx.config().getMarshaller(), in, U.resolveClassLoader(ctx.config()));
+
+                metadataLocCache.put(meta.typeId(), new BinaryMetadataHolder(meta, 0, 0));
+            }
+            catch (Exception e) {
+                U.warn(log, "Failed to restore metadata from file: " + file.getName() +
+                    "; exception was thrown: " + e.getMessage());
+            }
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/92f66b23/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/binary/BinaryMetadataTransport.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/binary/BinaryMetadataTransport.java
b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/binary/BinaryMetadataTransport.java
index e4df075..59c4856 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/binary/BinaryMetadataTransport.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/binary/BinaryMetadataTransport.java
@@ -75,6 +75,9 @@ final class BinaryMetadataTransport {
     private final ConcurrentMap<Integer, BinaryMetadataHolder> metaLocCache;
 
     /** */
+    private final BinaryMetadataFileStore metadataFileStore;
+
+    /** */
     private final Queue<MetadataUpdateResultFuture> unlabeledFutures = new ConcurrentLinkedQueue<>();
 
     /** */
@@ -91,12 +94,20 @@ final class BinaryMetadataTransport {
 
     /**
      * @param metaLocCache Metadata locale cache.
+     * @param metadataFileStore File store for binary metadata.
      * @param ctx Context.
      * @param log Logger.
      */
-    BinaryMetadataTransport(ConcurrentMap<Integer, BinaryMetadataHolder> metaLocCache,
final GridKernalContext ctx, IgniteLogger log) {
+    BinaryMetadataTransport(
+        ConcurrentMap<Integer, BinaryMetadataHolder> metaLocCache,
+        BinaryMetadataFileStore metadataFileStore,
+        final GridKernalContext ctx,
+        IgniteLogger log
+    ) {
         this.metaLocCache = metaLocCache;
 
+        this.metadataFileStore = metadataFileStore;
+
         this.ctx = ctx;
 
         this.log = log;
@@ -441,6 +452,8 @@ final class BinaryMetadataTransport {
                 }
 
                 metaLocCache.put(typeId, new BinaryMetadataHolder(holder.metadata(), holder.pendingVersion(),
newAcceptedVer));
+
+                metadataFileStore.saveMetadata(holder.metadata());
             }
 
             for (BinaryMetadataUpdatedListener lsnr : binaryUpdatedLsnrs)

http://git-wip-us.apache.org/repos/asf/ignite/blob/92f66b23/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/binary/CacheObjectBinaryProcessorImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/binary/CacheObjectBinaryProcessorImpl.java
b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/binary/CacheObjectBinaryProcessorImpl.java
index 83e2997..329c50e 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/binary/CacheObjectBinaryProcessorImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/binary/CacheObjectBinaryProcessorImpl.java
@@ -107,6 +107,9 @@ public class CacheObjectBinaryProcessorImpl extends IgniteCacheObjectProcessorIm
     private GridBinaryMarshaller binaryMarsh;
 
     /** */
+    private BinaryMetadataFileStore metadataFileStore;
+
+    /** */
     @GridToStringExclude
     private IgniteBinary binaries;
 
@@ -143,7 +146,11 @@ public class CacheObjectBinaryProcessorImpl extends IgniteCacheObjectProcessorIm
             if (ctx.clientNode())
                 ctx.event().addLocalEventListener(clientDisconLsnr, EVT_CLIENT_NODE_DISCONNECTED);
 
-            transport = new BinaryMetadataTransport(metadataLocCache, ctx, log);
+            metadataFileStore = new BinaryMetadataFileStore(metadataLocCache, ctx, log);
+
+            metadataFileStore.restoreMetadata();
+
+            transport = new BinaryMetadataTransport(metadataLocCache, metadataFileStore,
ctx, log);
 
             BinaryMetadataHandler metaHnd = new BinaryMetadataHandler() {
                 @Override public void addMeta(int typeId, BinaryType newMeta) throws BinaryObjectException
{
@@ -158,7 +165,7 @@ public class CacheObjectBinaryProcessorImpl extends IgniteCacheObjectProcessorIm
                         BinaryMetadata mergedMeta = BinaryUtils.mergeMetadata(oldMeta, ((BinaryTypeImpl)newMeta).metadata());
 
                         if (oldMeta != mergedMeta)
-                            metadataLocCache.putIfAbsent(typeId, new BinaryMetadataHolder(mergedMeta,
0, 0));
+                            metadataLocCache.put(typeId, new BinaryMetadataHolder(mergedMeta,
0, 0));
 
                         return;
                     }
@@ -881,6 +888,9 @@ public class CacheObjectBinaryProcessorImpl extends IgniteCacheObjectProcessorIm
                     log.debug("Received metadata on join: " + localHolder);
 
                 metadataLocCache.put(e.getKey(), localHolder);
+
+                if (!ctx.clientNode())
+                    metadataFileStore.saveMetadata(holder.metadata());
             }
         }
     }

http://git-wip-us.apache.org/repos/asf/ignite/blob/92f66b23/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/IgnitePdsBinaryMetadataOnClusterRestartTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/IgnitePdsBinaryMetadataOnClusterRestartTest.java
b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/IgnitePdsBinaryMetadataOnClusterRestartTest.java
new file mode 100644
index 0000000..cc3820b
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/persistence/IgnitePdsBinaryMetadataOnClusterRestartTest.java
@@ -0,0 +1,514 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.ignite.internal.processors.cache.persistence;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Collection;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.IgniteCheckedException;
+import org.apache.ignite.binary.BinaryObject;
+import org.apache.ignite.binary.BinaryType;
+import org.apache.ignite.binary.BinaryTypeConfiguration;
+import org.apache.ignite.cache.CacheKeyConfiguration;
+import org.apache.ignite.cache.CacheMode;
+import org.apache.ignite.cache.affinity.AffinityKeyMapped;
+import org.apache.ignite.cache.affinity.rendezvous.RendezvousAffinityFunction;
+import org.apache.ignite.configuration.BinaryConfiguration;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.configuration.IgniteConfiguration;
+import org.apache.ignite.configuration.PersistentStoreConfiguration;
+import org.apache.ignite.configuration.WALMode;
+import org.apache.ignite.internal.util.typedef.F;
+import org.apache.ignite.internal.util.typedef.internal.U;
+import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
+
+/**
+ *
+ */
+public class IgnitePdsBinaryMetadataOnClusterRestartTest extends GridCommonAbstractTest {
+    /** */
+    private static final String CACHE_NAME = "cache1";
+
+    /** */
+    private static final String DYNAMIC_TYPE_NAME = "DynamicType";
+
+    /** */
+    private static final String DYNAMIC_INT_FIELD_NAME = "intField";
+
+    /** */
+    private static final String DYNAMIC_STR_FIELD_NAME = "strField";
+
+    /** */
+    private boolean clientMode;
+
+    /** {@inheritDoc} */
+    @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception
{
+        IgniteConfiguration cfg = super.getConfiguration(gridName);
+
+        cfg.setClientMode(clientMode);
+
+        cfg.setPersistentStoreConfiguration(
+            new PersistentStoreConfiguration()
+                .setWalMode(WALMode.LOG_ONLY)
+        );
+
+        BinaryConfiguration bCfg = new BinaryConfiguration();
+
+        BinaryTypeConfiguration binaryEnumCfg = new BinaryTypeConfiguration(EnumType.class.getName());
+
+        binaryEnumCfg.setEnum(true);
+        binaryEnumCfg.setEnumValues(F.asMap(EnumType.ENUM_VAL_0.name(),
+            EnumType.ENUM_VAL_0.ordinal(),
+            EnumType.ENUM_VAL_1.name(),
+            EnumType.ENUM_VAL_1.ordinal()));
+
+        bCfg.setTypeConfigurations(Arrays.asList(binaryEnumCfg));
+
+        cfg.setBinaryConfiguration(bCfg);
+
+        CacheKeyConfiguration dynamicMetaKeyCfg = new CacheKeyConfiguration(DYNAMIC_TYPE_NAME,
DYNAMIC_INT_FIELD_NAME);
+
+        cfg.setCacheKeyConfiguration(dynamicMetaKeyCfg);
+
+        cfg.setCacheConfiguration(new CacheConfiguration()
+            .setName(CACHE_NAME)
+            .setAffinity(new RendezvousAffinityFunction())
+            .setCacheMode(CacheMode.REPLICATED));
+
+        return cfg;
+    }
+
+    /**
+     * Test verifies that binary metadata from regular java classes is saved and restored
correctly
+     * on cluster restart.
+     */
+    public void testStaticMetadataIsRestoredOnRestart() throws Exception {
+        clientMode = false;
+
+        startGrids(2);
+
+        Ignite ignite0 = grid(0);
+
+        ignite0.active(true);
+
+        IgniteCache<Object, Object> cache0 = ignite0.cache(CACHE_NAME);
+
+        cache0.put(0, new TestValue1(0));
+        cache0.put(1, new TestValue2("value"));
+
+        stopAllGrids();
+
+        startGrids(2);
+
+        ignite0 = grid(0);
+
+        ignite0.active(true);
+
+        examineStaticMetadata(2);
+
+        startGrid(2);
+
+        startGrid(3);
+
+        awaitPartitionMapExchange();
+
+        examineStaticMetadata(4);
+    }
+
+    /**
+     * @param nodesCnt Number of nodes in grid.
+     */
+    private void examineStaticMetadata(int nodesCnt) {
+        for (int i = 0; i < nodesCnt; i++) {
+            IgniteCache cache = grid(i).cache(CACHE_NAME).withKeepBinary();
+
+            BinaryObject o1 = (BinaryObject) cache.get(0);
+
+            TestValue1 t1 = o1.deserialize();
+
+            assertEquals(0, t1.getValue());
+
+            BinaryObject o2 = (BinaryObject) cache.get(1);
+
+            TestValue2 t2 = o2.deserialize();
+
+            assertEquals("value", t2.getValue());
+
+            assertEquals(TestValue1.class.getName(), o1.type().typeName());
+            assertEquals(TestValue2.class.getName(), o2.type().typeName());
+
+            assertEquals("val", o1.type().affinityKeyFieldName());
+        }
+    }
+
+    /**
+     * @param nodesCount Nodes count.
+     */
+    private void examineDynamicMetadata(int nodesCount, BinaryObjectExaminer... examiners)
{
+        for (int i = 0; i < nodesCount; i++) {
+            Ignite ignite = grid(i);
+
+            for (BinaryObjectExaminer examiner : examiners)
+                examiner.examine(ignite.cache(CACHE_NAME).withKeepBinary());
+        }
+    }
+
+    /**
+     * Test verifies that metadata for binary types built with BinaryObjectBuilder is saved
and updated correctly
+     * on cluster restart.
+     */
+    public void testDynamicMetadataIsRestoredOnRestart() throws Exception {
+        clientMode = false;
+        //1: start two nodes, add single BinaryObject
+        startGrids(2);
+
+        Ignite ignite0 = grid(0);
+
+        ignite0.active(true);
+
+        IgniteCache<Object, Object> cache0 = ignite0.cache(CACHE_NAME);
+
+        BinaryObject bo = ignite0
+            .binary()
+            .builder(DYNAMIC_TYPE_NAME)
+            .setField(DYNAMIC_INT_FIELD_NAME, 10)
+            .build();
+
+        cache0.put(2, bo);
+
+        stopAllGrids();
+
+        //2: start two nodes, check BinaryObject added on step 1) (field values, metadata
info),
+        // modify BinaryObject type, add new instance of modified type
+        startGrids(2);
+
+        ignite0 = grid(0);
+
+        ignite0.active(true);
+
+        examineDynamicMetadata(2, contentExaminer0, structureExaminer0);
+
+        Ignite ignite1 = grid(1);
+
+        BinaryObject bo1 = ignite1
+            .binary()
+            .builder(DYNAMIC_TYPE_NAME)
+            .setField(DYNAMIC_INT_FIELD_NAME, 20)
+            .setField(DYNAMIC_STR_FIELD_NAME, "str")
+            .build();
+
+        ignite1.cache(CACHE_NAME).put(3, bo1);
+
+        stopAllGrids();
+
+        //3: start two nodes, check both BinaryObject instances,
+        // start two additional nodes, check BO instances on all nodes
+        startGrids(2);
+
+        ignite0 = grid(0);
+
+        ignite0.active(true);
+
+        examineDynamicMetadata(2, contentExaminer0, contentExaminer1, structureExaminer1);
+
+        startGrid(2);
+
+        startGrid(3);
+
+        awaitPartitionMapExchange();
+
+        examineDynamicMetadata(4, contentExaminer0, contentExaminer1, structureExaminer1);
+    }
+
+    /**
+     *
+     */
+    public void testBinaryEnumMetadataIsRestoredOnRestart() throws Exception {
+        clientMode = false;
+
+        Ignite ignite0 = startGrids(2);
+
+        ignite0.active(true);
+
+        BinaryObject enumBo0 = ignite0.binary().buildEnum(EnumType.class.getName(), 0);
+
+        ignite0.cache(CACHE_NAME).put(4, enumBo0);
+
+        stopAllGrids();
+
+        ignite0 = startGrids(2);
+
+        ignite0.active(true);
+
+        startGrid(2);
+
+        awaitPartitionMapExchange();
+
+        examineDynamicMetadata(3, enumExaminer0);
+
+        stopAllGrids();
+
+        ignite0 = startGrids(3);
+
+        ignite0.active(true);
+
+        clientMode = true;
+
+        startGrid(3);
+
+        awaitPartitionMapExchange();
+
+        examineDynamicMetadata(4, enumExaminer0);
+    }
+
+    /**
+     * Test verifies that metadata is saved, stored and delivered to client nodes correctly.
+     */
+    public void testMixedMetadataIsRestoredOnRestart() throws Exception {
+        clientMode = false;
+
+        //1: starts 4 nodes one by one and adds java classes and classless BinaryObjects
+        // to the same replicated cache from different nodes.
+        // Examines all objects in cache (field values and metadata).
+        Ignite ignite0 = startGrid(0);
+
+        ignite0.active(true);
+
+        IgniteCache cache0 = ignite0.cache(CACHE_NAME);
+
+        cache0.put(0, new TestValue1(0));
+
+        startGrid(1);
+
+        awaitPartitionMapExchange();
+
+        grid(1).cache(CACHE_NAME).put(1, new TestValue2("value"));
+
+        Ignite ignite2 = startGrid(2);
+
+        awaitPartitionMapExchange();
+
+        BinaryObject bo0 = ignite2.binary().builder(DYNAMIC_TYPE_NAME).setField(DYNAMIC_INT_FIELD_NAME,
10).build();
+
+        ignite2.cache(CACHE_NAME).put(2, bo0);
+
+        Ignite ignite3 = startGrid(3);
+
+        awaitPartitionMapExchange();
+
+        BinaryObject bo1 = ignite3
+            .binary()
+            .builder(DYNAMIC_TYPE_NAME)
+            .setField(DYNAMIC_INT_FIELD_NAME, 20)
+            .setField(DYNAMIC_STR_FIELD_NAME, "str")
+            .build();
+
+        ignite3.cache(CACHE_NAME).put(3, bo1);
+
+        stopAllGrids();
+
+        startGrids(4);
+
+        grid(0).active(true);
+
+        examineStaticMetadata(4);
+
+        examineDynamicMetadata(4, contentExaminer0, contentExaminer1, structureExaminer1);
+
+        //2: starts up client node and performs the same set of checks from all nodes including
client
+        clientMode = true;
+
+        startGrid(4);
+
+        examineStaticMetadata(5);
+
+        examineDynamicMetadata(5, contentExaminer0, contentExaminer1, structureExaminer1);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void afterTest() throws Exception {
+        stopAllGrids();
+
+        cleanIgniteWorkDir();
+    }
+
+    /**
+     *
+     */
+    private void cleanIgniteWorkDir() throws IgniteCheckedException {
+        String baseDir = U.defaultWorkDirectory();
+
+        File baseDirFile = new File(baseDir);
+
+        for (File f : baseDirFile.listFiles())
+            deleteRecursively(U.resolveWorkDirectory(baseDir, f.getName(), false));
+    }
+
+    /**
+     *
+     */
+    private static class TestValue1 {
+        /** */
+        @AffinityKeyMapped
+        private final int val;
+
+        /**
+         * @param val Value.
+         */
+        TestValue1(int val) {
+            this.val = val;
+        }
+
+        /**
+         *
+         */
+        int getValue() {
+            return val;
+        }
+    }
+
+    /**
+     *
+     */
+    private static class TestValue2 {
+        /** */
+        private final String val;
+
+        /**
+         * @param val Value.
+         */
+        TestValue2(String val) {
+            this.val = val;
+        }
+
+        /**
+         *
+         */
+        String getValue() {
+            return val;
+        }
+    }
+
+    /** */
+    private enum EnumType {
+        /** */ ENUM_VAL_0,
+        /** */ ENUM_VAL_1
+    }
+
+    /**
+     *
+     */
+    private static interface BinaryObjectExaminer {
+        /**
+         * @param cache Cache.
+         */
+        void examine(IgniteCache cache);
+    }
+
+    /** */
+    private BinaryObjectExaminer contentExaminer0 = new BinaryObjectExaminer() {
+        @Override public void examine(IgniteCache cache) {
+            BinaryObject bo = (BinaryObject) cache.get(2);
+
+            int fieldVal = bo.field(DYNAMIC_INT_FIELD_NAME);
+
+            assertEquals(10, fieldVal);
+        }
+    };
+
+    /** */
+    private BinaryObjectExaminer contentExaminer1 = new BinaryObjectExaminer() {
+        @Override public void examine(IgniteCache cache) {
+            BinaryObject bo = (BinaryObject) cache.get(3);
+
+            int fieldVal = bo.field(DYNAMIC_INT_FIELD_NAME);
+
+            assertEquals(20, fieldVal);
+            assertEquals("str", bo.field(DYNAMIC_STR_FIELD_NAME));
+        }
+    };
+
+    /** */
+    private BinaryObjectExaminer structureExaminer0 = new BinaryObjectExaminer() {
+        @Override public void examine(IgniteCache cache) {
+            BinaryObject bo = (BinaryObject) cache.get(2);
+
+            BinaryType type = bo.type();
+
+            assertFalse(type.isEnum());
+
+            assertEquals(DYNAMIC_TYPE_NAME, type.typeName());
+
+            Collection<String> fieldNames = type.fieldNames();
+
+            assertEquals(1, fieldNames.size());
+
+            assertTrue(fieldNames.contains(DYNAMIC_INT_FIELD_NAME));
+
+            assertEquals(DYNAMIC_INT_FIELD_NAME, type.affinityKeyFieldName());
+        }
+    };
+
+    /** */
+    private BinaryObjectExaminer structureExaminer1 = new BinaryObjectExaminer() {
+        @Override public void examine(IgniteCache cache) {
+            BinaryObject bo = (BinaryObject) cache.get(2);
+
+            BinaryType type = bo.type();
+
+            assertFalse(bo.type().isEnum());
+
+            assertEquals(DYNAMIC_TYPE_NAME, type.typeName());
+
+            Collection<String> fieldNames = type.fieldNames();
+
+            assertEquals(2, fieldNames.size());
+
+            assertTrue(fieldNames.contains(DYNAMIC_INT_FIELD_NAME));
+            assertTrue(fieldNames.contains(DYNAMIC_STR_FIELD_NAME));
+        }
+    };
+
+    /** */
+    private BinaryObjectExaminer enumExaminer0 = new BinaryObjectExaminer() {
+        @Override public void examine(IgniteCache cache) {
+            BinaryObject enumBo = (BinaryObject) cache.get(4);
+
+            assertEquals(EnumType.ENUM_VAL_0.ordinal(), enumBo.enumOrdinal());
+
+            BinaryType type = enumBo.type();
+
+            assertTrue(type.isEnum());
+
+            assertEquals(EnumType.class.getName(), type.typeName());
+
+            Collection<BinaryObject> enumVals = type.enumValues();
+
+            assertEquals(2, enumVals.size());
+
+            int i = 0;
+
+            for (BinaryObject bo : enumVals) {
+                assertEquals(i, bo.enumOrdinal());
+
+                assertEquals("ENUM_VAL_" + (i++), bo.enumName());
+            }
+        }
+    };
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/92f66b23/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
index fc828a8..01b27ad 100644
--- a/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
@@ -537,6 +537,7 @@ public abstract class GridAbstractTest extends TestCase {
     protected void beforeTestsStarted() throws Exception {
         // Will clean and re-create marshaller directory from scratch.
         U.resolveWorkDirectory(U.defaultWorkDirectory(), "marshaller", true);
+        U.resolveWorkDirectory(U.defaultWorkDirectory(), "binary_meta", true);
     }
 
     /**

http://git-wip-us.apache.org/repos/asf/ignite/blob/92f66b23/modules/indexing/src/test/java/org/apache/ignite/testsuites/IgnitePdsWithIndexingCoreTestSuite.java
----------------------------------------------------------------------
diff --git a/modules/indexing/src/test/java/org/apache/ignite/testsuites/IgnitePdsWithIndexingCoreTestSuite.java
b/modules/indexing/src/test/java/org/apache/ignite/testsuites/IgnitePdsWithIndexingCoreTestSuite.java
index eda99ce..bb9c9d1 100644
--- a/modules/indexing/src/test/java/org/apache/ignite/testsuites/IgnitePdsWithIndexingCoreTestSuite.java
+++ b/modules/indexing/src/test/java/org/apache/ignite/testsuites/IgnitePdsWithIndexingCoreTestSuite.java
@@ -18,6 +18,7 @@ package org.apache.ignite.testsuites;
 
 import junit.framework.TestSuite;
 import org.apache.ignite.internal.processors.cache.persistence.IgnitePdsAtomicCacheRebalancingTest;
+import org.apache.ignite.internal.processors.cache.persistence.IgnitePdsBinaryMetadataOnClusterRestartTest;
 import org.apache.ignite.internal.processors.cache.persistence.IgnitePdsTxCacheRebalancingTest;
 import org.apache.ignite.internal.processors.cache.persistence.IgnitePersistentStoreCacheGroupsTest;
 import org.apache.ignite.internal.processors.cache.persistence.db.IgnitePdsMultiNodePutGetRestartTest;
@@ -49,6 +50,8 @@ public class IgnitePdsWithIndexingCoreTestSuite extends TestSuite {
         suite.addTestSuite(IgnitePdsAtomicCacheRebalancingTest.class);
         suite.addTestSuite(IgnitePdsTxCacheRebalancingTest.class);
 
+        suite.addTestSuite(IgnitePdsBinaryMetadataOnClusterRestartTest.class);
+
         return suite;
     }
 }


Mime
View raw message