Examples with CacheStoreManager org.apache.ignite.internal.processors.cache.store.CacheStoreManager used on opensource projects

Example 1 with CacheStoreManager

use of org.apache.ignite.internal.processors.cache.store.CacheStoreManager in project ignite by apache.

the class GridCacheProcessor method createCache.

/**
     * @param cfg Cache configuration to use to create cache.
     * @param pluginMgr Cache plugin manager.
     * @param desc Cache descriptor.
     * @param locStartTopVer Current topology version.
     * @param cacheObjCtx Cache object context.
     * @param affNode {@code True} if local node affinity node.
     * @param updatesAllowed Updates allowed flag.
     * @return Cache context.
     * @throws IgniteCheckedException If failed to create cache.
     */
private GridCacheContext createCache(CacheConfiguration<?, ?> cfg, @Nullable CachePluginManager pluginMgr, DynamicCacheDescriptor desc, AffinityTopologyVersion locStartTopVer, CacheObjectContext cacheObjCtx, boolean affNode, boolean updatesAllowed) throws IgniteCheckedException {
    assert cfg != null;
    if (cfg.getCacheStoreFactory() instanceof GridCacheLoaderWriterStoreFactory) {
        GridCacheLoaderWriterStoreFactory factory = (GridCacheLoaderWriterStoreFactory) cfg.getCacheStoreFactory();
        prepare(cfg, factory.loaderFactory(), false);
        prepare(cfg, factory.writerFactory(), false);
    } else
        prepare(cfg, cfg.getCacheStoreFactory(), false);
    CacheStore cfgStore = cfg.getCacheStoreFactory() != null ? cfg.getCacheStoreFactory().create() : null;
    validate(ctx.config(), cfg, desc.cacheType(), cfgStore);
    if (pluginMgr == null)
        pluginMgr = new CachePluginManager(ctx, cfg);
    pluginMgr.validate();
    sharedCtx.jta().registerCache(cfg);
    // Skip suggestions for internal caches.
    if (desc.cacheType().userCache())
        suggestOptimizations(cfg, cfgStore != null);
    Collection<Object> toPrepare = new ArrayList<>();
    if (cfgStore instanceof GridCacheLoaderWriterStore) {
        toPrepare.add(((GridCacheLoaderWriterStore) cfgStore).loader());
        toPrepare.add(((GridCacheLoaderWriterStore) cfgStore).writer());
    } else
        toPrepare.add(cfgStore);
    prepare(cfg, toPrepare);
    U.startLifecycleAware(lifecycleAwares(cfg, cfgStore));
    boolean nearEnabled = GridCacheUtils.isNearEnabled(cfg);
    GridCacheAffinityManager affMgr = new GridCacheAffinityManager();
    GridCacheEventManager evtMgr = new GridCacheEventManager();
    CacheEvictionManager evictMgr = (nearEnabled || cfg.isOnheapCacheEnabled()) ? new GridCacheEvictionManager() : new CacheOffheapEvictionManager();
    GridCacheQueryManager qryMgr = queryManager(cfg);
    CacheContinuousQueryManager contQryMgr = new CacheContinuousQueryManager();
    CacheDataStructuresManager dataStructuresMgr = new CacheDataStructuresManager();
    GridCacheTtlManager ttlMgr = new GridCacheTtlManager();
    CacheConflictResolutionManager rslvrMgr = pluginMgr.createComponent(CacheConflictResolutionManager.class);
    GridCacheDrManager drMgr = pluginMgr.createComponent(GridCacheDrManager.class);
    CacheStoreManager storeMgr = pluginMgr.createComponent(CacheStoreManager.class);
    IgniteCacheOffheapManager offheapMgr = pluginMgr.createComponent(IgniteCacheOffheapManager.class);
    storeMgr.initialize(cfgStore, sesHolders);
    String memPlcName = cfg.getMemoryPolicyName();
    MemoryPolicy memPlc = sharedCtx.database().memoryPolicy(memPlcName);
    FreeList freeList = sharedCtx.database().freeList(memPlcName);
    ReuseList reuseList = sharedCtx.database().reuseList(memPlcName);
    GridCacheContext<?, ?> cacheCtx = new GridCacheContext(ctx, sharedCtx, cfg, desc.cacheType(), locStartTopVer, desc.receivedFrom(), affNode, updatesAllowed, memPlc, freeList, reuseList, /*
             * Managers in starting order!
             * ===========================
             */
    evtMgr, storeMgr, evictMgr, qryMgr, contQryMgr, dataStructuresMgr, ttlMgr, drMgr, offheapMgr, rslvrMgr, pluginMgr, affMgr);
    cacheCtx.cacheObjectContext(cacheObjCtx);
    GridCacheAdapter cache = null;
    switch(cfg.getCacheMode()) {
        case LOCAL:
            {
                switch(cfg.getAtomicityMode()) {
                    case TRANSACTIONAL:
                        {
                            cache = new GridLocalCache(cacheCtx);
                            break;
                        }
                    case ATOMIC:
                        {
                            cache = new GridLocalAtomicCache(cacheCtx);
                            break;
                        }
                    default:
                        {
                            assert false : "Invalid cache atomicity mode: " + cfg.getAtomicityMode();
                        }
                }
                break;
            }
        case PARTITIONED:
        case REPLICATED:
            {
                if (nearEnabled) {
                    switch(cfg.getAtomicityMode()) {
                        case TRANSACTIONAL:
                            {
                                cache = new GridNearTransactionalCache(cacheCtx);
                                break;
                            }
                        case ATOMIC:
                            {
                                cache = new GridNearAtomicCache(cacheCtx);
                                break;
                            }
                        default:
                            {
                                assert false : "Invalid cache atomicity mode: " + cfg.getAtomicityMode();
                            }
                    }
                } else {
                    switch(cfg.getAtomicityMode()) {
                        case TRANSACTIONAL:
                            {
                                cache = cacheCtx.affinityNode() ? new GridDhtColocatedCache(cacheCtx) : new GridDhtColocatedCache(cacheCtx, new GridNoStorageCacheMap(cacheCtx));
                                break;
                            }
                        case ATOMIC:
                            {
                                cache = cacheCtx.affinityNode() ? new GridDhtAtomicCache(cacheCtx) : new GridDhtAtomicCache(cacheCtx, new GridNoStorageCacheMap(cacheCtx));
                                break;
                            }
                        default:
                            {
                                assert false : "Invalid cache atomicity mode: " + cfg.getAtomicityMode();
                            }
                    }
                }
                break;
            }
        default:
            {
                assert false : "Invalid cache mode: " + cfg.getCacheMode();
            }
    }
    cacheCtx.cache(cache);
    GridCacheContext<?, ?> ret = cacheCtx;
    /*
         * Create DHT cache.
         * ================
         */
    if (cfg.getCacheMode() != LOCAL && nearEnabled) {
        /*
             * Specifically don't create the following managers
             * here and reuse the one from Near cache:
             * 1. GridCacheVersionManager
             * 2. GridCacheIoManager
             * 3. GridCacheDeploymentManager
             * 4. GridCacheQueryManager (note, that we start it for DHT cache though).
             * 5. CacheContinuousQueryManager (note, that we start it for DHT cache though).
             * 6. GridCacheDgcManager
             * 7. GridCacheTtlManager.
             * ===============================================
             */
        evictMgr = cfg.isOnheapCacheEnabled() ? new GridCacheEvictionManager() : new CacheOffheapEvictionManager();
        evtMgr = new GridCacheEventManager();
        pluginMgr = new CachePluginManager(ctx, cfg);
        drMgr = pluginMgr.createComponent(GridCacheDrManager.class);
        cacheCtx = new GridCacheContext(ctx, sharedCtx, cfg, desc.cacheType(), locStartTopVer, desc.receivedFrom(), affNode, true, memPlc, freeList, reuseList, /*
                 * Managers in starting order!
                 * ===========================
                 */
        evtMgr, storeMgr, evictMgr, qryMgr, contQryMgr, dataStructuresMgr, ttlMgr, drMgr, offheapMgr, rslvrMgr, pluginMgr, affMgr);
        cacheCtx.cacheObjectContext(cacheObjCtx);
        GridDhtCacheAdapter dht = null;
        switch(cfg.getAtomicityMode()) {
            case TRANSACTIONAL:
                {
                    assert cache instanceof GridNearTransactionalCache;
                    GridNearTransactionalCache near = (GridNearTransactionalCache) cache;
                    GridDhtCache dhtCache = cacheCtx.affinityNode() ? new GridDhtCache(cacheCtx) : new GridDhtCache(cacheCtx, new GridNoStorageCacheMap(cacheCtx));
                    dhtCache.near(near);
                    near.dht(dhtCache);
                    dht = dhtCache;
                    break;
                }
            case ATOMIC:
                {
                    assert cache instanceof GridNearAtomicCache;
                    GridNearAtomicCache near = (GridNearAtomicCache) cache;
                    GridDhtAtomicCache dhtCache = cacheCtx.affinityNode() ? new GridDhtAtomicCache(cacheCtx) : new GridDhtAtomicCache(cacheCtx, new GridNoStorageCacheMap(cacheCtx));
                    dhtCache.near(near);
                    near.dht(dhtCache);
                    dht = dhtCache;
                    break;
                }
            default:
                {
                    assert false : "Invalid cache atomicity mode: " + cfg.getAtomicityMode();
                }
        }
        cacheCtx.cache(dht);
    }
    if (!CU.isUtilityCache(cache.name()) && !CU.isSystemCache(cache.name())) {
        registerMbean(cache.localMxBean(), cache.name(), false);
        registerMbean(cache.clusterMxBean(), cache.name(), false);
    }
    return ret;
}

Example 2 with CacheStoreManager

use of org.apache.ignite.internal.processors.cache.store.CacheStoreManager in project ignite by apache.

the class IgniteTxAdapter method sessionEnd.

/**
 * @param stores Store managers.
 * @param commit Commit flag.
 * @throws IgniteCheckedException In case of error.
 */
protected void sessionEnd(final Collection<CacheStoreManager> stores, boolean commit) throws IgniteCheckedException {
    Iterator<CacheStoreManager> it = stores.iterator();
    Set<CacheStore> visited = new GridSetWrapper<>(new IdentityHashMap<CacheStore, Object>());
    while (it.hasNext()) {
        CacheStoreManager store = it.next();
        store.sessionEnd(this, commit, !it.hasNext(), !visited.add(store.store()));
    }
}

Example 3 with CacheStoreManager

use of org.apache.ignite.internal.processors.cache.store.CacheStoreManager in project ignite by apache.

the class IgniteTxAdapter method batchStoreCommit.

/**
 * Performs batch database operations. This commit must be called
 * before cache update. This way if there is a DB failure,
 * cache transaction can still be rolled back.
 *
 * @param writeEntries Transaction write set.
 * @throws IgniteCheckedException If batch update failed.
 */
protected final void batchStoreCommit(Iterable<IgniteTxEntry> writeEntries) throws IgniteCheckedException {
    if (!storeEnabled() || internal() || // No need to work with local store at GridNearTxRemote.
    (!local() && near()))
        return;
    Collection<CacheStoreManager> stores = txState().stores(cctx);
    if (stores == null || stores.isEmpty())
        return;
    assert isWriteToStoreFromDhtValid(stores) : "isWriteToStoreFromDht can't be different within one transaction";
    CacheStoreManager first = F.first(stores);
    boolean isWriteToStoreFromDht = first.isWriteToStoreFromDht();
    if ((local() || first.isLocal()) && (near() || isWriteToStoreFromDht)) {
        try {
            if (writeEntries != null) {
                Map<KeyCacheObject, IgniteBiTuple<? extends CacheObject, GridCacheVersion>> putMap = null;
                List<KeyCacheObject> rmvCol = null;
                CacheStoreManager writeStore = null;
                boolean skipNonPrimary = near() && isWriteToStoreFromDht;
                for (IgniteTxEntry e : writeEntries) {
                    boolean skip = e.skipStore();
                    if (!skip && skipNonPrimary) {
                        skip = e.cached().isNear() || e.cached().detached() || !e.context().affinity().primaryByPartition(e.cached().partition(), topologyVersion()).isLocal();
                    }
                    if (// Update local store at backups only if needed.
                    !skip && !local() && cctx.localStorePrimaryOnly())
                        skip = true;
                    if (skip)
                        continue;
                    boolean intercept = e.context().config().getInterceptor() != null;
                    if (intercept || !F.isEmpty(e.entryProcessors()))
                        e.cached().unswap(false);
                    IgniteBiTuple<GridCacheOperation, CacheObject> res = applyTransformClosures(e, false, null);
                    GridCacheContext cacheCtx = e.context();
                    GridCacheOperation op = res.get1();
                    KeyCacheObject key = e.key();
                    CacheObject val = res.get2();
                    GridCacheVersion ver = writeVersion();
                    if (op == CREATE || op == UPDATE) {
                        // Batch-process all removes if needed.
                        if (rmvCol != null && !rmvCol.isEmpty()) {
                            assert writeStore != null;
                            writeStore.removeAll(this, rmvCol);
                            // Reset.
                            rmvCol.clear();
                            writeStore = null;
                        }
                        // Batch-process puts if cache ID has changed.
                        if (writeStore != null && writeStore != cacheCtx.store()) {
                            if (putMap != null && !putMap.isEmpty()) {
                                writeStore.putAll(this, putMap);
                                // Reset.
                                putMap.clear();
                            }
                            writeStore = null;
                        }
                        if (intercept) {
                            Object interceptorVal = cacheCtx.config().getInterceptor().onBeforePut(new CacheLazyEntry(cacheCtx, key, e.cached().rawGet(), e.keepBinary()), cacheCtx.cacheObjectContext().unwrapBinaryIfNeeded(val, e.keepBinary(), false, null));
                            if (interceptorVal == null)
                                continue;
                            val = cacheCtx.toCacheObject(cacheCtx.unwrapTemporary(interceptorVal));
                        }
                        if (writeStore == null)
                            writeStore = cacheCtx.store();
                        if (writeStore.isWriteThrough()) {
                            if (putMap == null)
                                putMap = new LinkedHashMap<>(writeMap().size(), 1.0f);
                            putMap.put(key, F.t(val, ver));
                        }
                    } else if (op == DELETE) {
                        // Batch-process all puts if needed.
                        if (putMap != null && !putMap.isEmpty()) {
                            assert writeStore != null;
                            writeStore.putAll(this, putMap);
                            // Reset.
                            putMap.clear();
                            writeStore = null;
                        }
                        if (writeStore != null && writeStore != cacheCtx.store()) {
                            if (rmvCol != null && !rmvCol.isEmpty()) {
                                writeStore.removeAll(this, rmvCol);
                                // Reset.
                                rmvCol.clear();
                            }
                            writeStore = null;
                        }
                        if (intercept) {
                            IgniteBiTuple<Boolean, Object> t = cacheCtx.config().getInterceptor().onBeforeRemove(new CacheLazyEntry(cacheCtx, key, e.cached().rawGet(), e.keepBinary()));
                            if (cacheCtx.cancelRemove(t))
                                continue;
                        }
                        if (writeStore == null)
                            writeStore = cacheCtx.store();
                        if (writeStore.isWriteThrough()) {
                            if (rmvCol == null)
                                rmvCol = new ArrayList<>();
                            rmvCol.add(key);
                        }
                    } else if (log.isDebugEnabled())
                        log.debug("Ignoring NOOP entry for batch store commit: " + e);
                }
                if (putMap != null && !putMap.isEmpty()) {
                    assert rmvCol == null || rmvCol.isEmpty();
                    assert writeStore != null;
                    // Batch put at the end of transaction.
                    writeStore.putAll(this, putMap);
                }
                if (rmvCol != null && !rmvCol.isEmpty()) {
                    assert putMap == null || putMap.isEmpty();
                    assert writeStore != null;
                    // Batch remove at the end of transaction.
                    writeStore.removeAll(this, rmvCol);
                }
            }
            // Commit while locks are held.
            sessionEnd(stores, true);
        } catch (IgniteCheckedException ex) {
            commitError(ex);
            errorWhenCommitting();
            // Safe to remove transaction from committed tx list because nothing was committed yet.
            cctx.tm().removeCommittedTx(this);
            throw ex;
        } catch (Throwable ex) {
            commitError(ex);
            errorWhenCommitting();
            // Safe to remove transaction from committed tx list because nothing was committed yet.
            cctx.tm().removeCommittedTx(this);
            if (ex instanceof Error)
                throw (Error) ex;
            throw new IgniteCheckedException("Failed to commit transaction to database: " + this, ex);
        } finally {
            if (isRollbackOnly())
                sessionEnd(stores, false);
        }
    } else
        sessionEnd(stores, true);
}

Example 4 with CacheStoreManager

use of org.apache.ignite.internal.processors.cache.store.CacheStoreManager in project ignite by apache.

the class IgniteTxStateImpl method storeWriteThrough.

/**
 * {@inheritDoc}
 */
@Override
public boolean storeWriteThrough(GridCacheSharedContext cctx) {
    if (!activeCacheIds.isEmpty()) {
        for (int i = 0; i < activeCacheIds.size(); i++) {
            int cacheId = activeCacheIds.get(i);
            CacheStoreManager store = cctx.cacheContext(cacheId).store();
            if (store.configured() && store.isWriteThrough())
                return true;
        }
    }
    return false;
}

Example 5 with CacheStoreManager

use of org.apache.ignite.internal.processors.cache.store.CacheStoreManager in project ignite by apache.

the class IgniteTxStateImpl method stores.

/**
 * {@inheritDoc}
 */
@Override
public Collection<CacheStoreManager> stores(GridCacheSharedContext cctx) {
    GridIntList cacheIds = activeCacheIds;
    if (!cacheIds.isEmpty()) {
        Collection<CacheStoreManager> stores = new ArrayList<>(cacheIds.size());
        for (int i = 0; i < cacheIds.size(); i++) {
            int cacheId = cacheIds.get(i);
            CacheStoreManager store = cctx.cacheContext(cacheId).store();
            if (store.configured())
                stores.add(store);
        }
        return stores;
    }
    return null;
}