# ignite-668

modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheType.java

@@ -0,0 +1,77 @@
+/*
+ * 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;
+
+import org.apache.ignite.internal.managers.communication.*;
+
+import static org.apache.ignite.internal.managers.communication.GridIoPolicy.*;
+
+/**
+ *
+ */
+public enum CacheType {
+    /**
+     * Regular cache created by user, visible via public API (e.g. {@link org.apache.ignite.Ignite#cache(String)}).
+     */
+    USER(true, SYSTEM_POOL),
+
+    /**
+     * Internal cache, should not be visible via public API (caches used by IGFS, Hadoop, data structures).
+     */
+    INTERNAL(false, SYSTEM_POOL),
+
+    /**
+     * Internal replicated cache, should use separate thread pool.
+     */
+    UTILITY(false, UTILITY_CACHE_POOL),
+
+    /**
+     * Internal marshaller cache, should use separate thread pool.
+     */
+    MARSHALLER(false, MARSH_CACHE_POOL);
+
+    /** */
+    private final boolean userCache;
+
+    /** */
+    private final GridIoPolicy ioPlc;
+
+    /**
+     * @param userCache {@code True} if cache created by user.
+     * @param ioPlc Cache IO policy.
+     */
+    CacheType(boolean userCache, GridIoPolicy ioPlc) {
+        this.userCache = userCache;
+        this.ioPlc = ioPlc;
+    }
+
+    /**
+     * @return Cache IO policy.
+     */
+    public GridIoPolicy ioPolicy() {
+        return ioPlc;
+    }
+
+    /**
+     * @return {@code True} if cache created by user.
+     */
+    public boolean userCache() {
+        return userCache;
+    }
+}
+

modules/core/src/main/java/org/apache/ignite/internal/processors/cache/DynamicCacheChangeRequest.java

@@ -42,6 +42,9 @@ public class DynamicCacheChangeRequest implements Serializable {
     /** Cache start configuration. */
     private CacheConfiguration startCfg;
 
+    /** Cache type. */
+    private CacheType cacheType;
+
     /** Near node ID in case if near cache is being started. */
     private UUID initiatingNodeId;
 
@@ -158,6 +161,20 @@ public void startCacheConfiguration(CacheConfiguration startCfg) {
         this.startCfg = startCfg;
     }
 
+    /**
+     * @param cacheType Cache type.
+     */
+    public void cacheType(CacheType cacheType) {
+        this.cacheType = cacheType;
+    }
+
+    /**
+     * @return Cache type.
+     */
+    public CacheType cacheType() {
+        return cacheType;
+    }
+
     /**
      * @return Client start only.
      */

modules/core/src/main/java/org/apache/ignite/internal/processors/cache/DynamicCacheDescriptor.java

@@ -47,17 +47,30 @@ public class DynamicCacheDescriptor {
     /** Started flag. */
     private boolean started;
 
+    /** Cache type. */
+    private CacheType cacheType;
+
     /** */
     private volatile Map<UUID, CacheConfiguration> rmtCfgs;
 
     /**
      * @param cacheCfg Cache configuration.
+     * @param cacheType Cache type.
+     * @param deploymentId Deployment ID.
      */
-    public DynamicCacheDescriptor(CacheConfiguration cacheCfg, IgniteUuid deploymentId) {
+    public DynamicCacheDescriptor(CacheConfiguration cacheCfg, CacheType cacheType, IgniteUuid deploymentId) {
         this.cacheCfg = cacheCfg;
+        this.cacheType = cacheType;
         this.deploymentId = deploymentId;
     }
 
+    /**
+     * @return Cache type.
+     */
+    public CacheType cacheType() {
+        return cacheType;
+    }
+
     /**
      * @return Start ID.
      */

modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java

@@ -2015,7 +2015,7 @@ public <K1, V1> IgniteInternalFuture<Map<K1, V1>> getAllAsync0(@Nullable final C
                 return new GridFinishedFuture<>(e);
             }
 
-            tx = ctx.tm().threadLocalTx(ctx.system() ? ctx : null);
+            tx = ctx.tm().threadLocalTx(ctx.systemTx() ? ctx : null);
         }
 
         if (tx == null || tx.implicit()) {
@@ -4368,7 +4368,7 @@ private int globalSize(boolean primaryOnly) throws IgniteCheckedException {
             tx = ctx.tm().newTx(
                 true,
                 op.single(),
-                ctx.system() ? ctx : null,
+                ctx.systemTx() ? ctx : null,
                 OPTIMISTIC,
                 READ_COMMITTED,
                 tCfg.getDefaultTxTimeout(),
@@ -4439,7 +4439,7 @@ private <T> IgniteInternalFuture<T> asyncOp(final AsyncOp<T> op) {
             tx = ctx.tm().newTx(
                 true,
                 op.single(),
-                ctx.system() ? ctx : null,
+                ctx.systemTx() ? ctx : null,
                 OPTIMISTIC,
                 READ_COMMITTED,
                 ctx.kernalContext().config().getTransactionConfiguration().getDefaultTxTimeout(),

modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheContext.java

@@ -166,8 +166,8 @@ public class GridCacheContext<K, V> implements Externalizable {
     /** Cache ID. */
     private int cacheId;
 
-    /** System cache flag. */
-    private boolean sys;
+    /** Cache type. */
+    private CacheType cacheType;
 
     /** IO policy. */
     private GridIoPolicy plc;
@@ -207,6 +207,8 @@ public GridCacheContext() {
      * @param ctx Kernal context.
      * @param sharedCtx Cache shared context.
      * @param cacheCfg Cache configuration.
+     * @param cacheType Cache type.
+     * @param affNode {@code True} if local node is affinity node.
      * @param evtMgr Cache event manager.
      * @param swapMgr Cache swap manager.
      * @param storeMgr Store manager.
@@ -218,13 +220,15 @@ public GridCacheContext() {
      * @param ttlMgr TTL manager.
      * @param drMgr Data center replication manager.
      * @param jtaMgr JTA manager.
+     * @param rslvrMgr Conflict resolution manager.
      * @param pluginMgr Cache plugin manager.
      */
     @SuppressWarnings({"unchecked"})
     public GridCacheContext(
         GridKernalContext ctx,
         GridCacheSharedContext sharedCtx,
         CacheConfiguration cacheCfg,
+        CacheType cacheType,
         boolean affNode,
 
         /*
@@ -265,6 +269,7 @@ public GridCacheContext(
         this.ctx = ctx;
         this.sharedCtx = sharedCtx;
         this.cacheCfg = cacheCfg;
+        this.cacheType = cacheType;
         this.affNode = affNode;
 
         /*
@@ -297,9 +302,7 @@ public GridCacheContext(
 
         cacheId = CU.cacheId(cacheName);
 
-        sys = ctx.cache().systemCache(cacheName);
-
-        plc = CU.isMarshallerCache(cacheName) ? MARSH_CACHE_POOL : sys ? UTILITY_CACHE_POOL : SYSTEM_POOL;
+        plc = cacheType.ioPolicy();
 
         Factory<ExpiryPolicy> factory = cacheCfg.getExpiryPolicyFactory();
 
@@ -434,10 +437,17 @@ public int cacheId() {
     }
 
     /**
-     * @return System cache flag.
+     * @return {@code True} if should use system transactions which are isolated from user transactions.
+     */
+    public boolean systemTx() {
+        return cacheType == CacheType.UTILITY;
+    }
+
+    /**
+     * @return {@code True} if cache created by user.
      */
-    public boolean system() {
-        return sys;
+    public boolean userCache() {
+        return cacheType.userCache();
     }
 
     /**

modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheDeploymentManager.java

@@ -256,7 +256,7 @@ private void onUndeploy0(final ClassLoader ldr, final GridCacheContext<K, V> cac
             cacheCtx.near().dht().context().swap().onUndeploy(ldr) :
             cacheCtx.swap().onUndeploy(ldr);
 
-        if (!cacheCtx.system()) {
+        if (cacheCtx.userCache()) {
             U.quietAndWarn(log, "");
             U.quietAndWarn(
                 log,

modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheEventManager.java

@@ -339,9 +339,7 @@ public void addUnloadEvent(int part) {
      * @return {@code True} if event is recordable.
      */
     public boolean isRecordable(int type) {
-        return !cctx.system() &&
-            !CU.isAtomicsCache(cctx.name()) &&
-            cctx.gridEvents().isRecordable(type);
+        return cctx.userCache() && cctx.gridEvents().isRecordable(type);
     }
 
     /** {@inheritDoc} */