/** {@inheritDoc} */ @Override protected void start0() throws IgniteCheckedException { if (srv) cctx.kernalContext().io().addMessageListener(TOPIC_WAL, ioLsnr); walDisableContext = new WALDisableContext( cctx.cache().context().database(), cctx.pageStore(), log ); cctx.kernalContext().internalSubscriptionProcessor().registerMetastorageListener(walDisableContext); }
/** * @return Cache transaction manager. */ public IgniteTxManager tm() { return sharedCtx.tm(); }
/** {@inheritDoc} */ @Override public void releaseHistoryForPreloading() { for (Map.Entry<T2<Integer, Integer>, T2<Long, WALPointer>> e : reservedForPreloading.entrySet()) { try { cctx.wal().release(e.getValue().get2()); } catch (IgniteCheckedException ex) { U.error(log, "Could not release WAL reservation", ex); throw new IgniteException(ex); } } reservedForPreloading.clear(); }
/** */ public MetaStorage( GridCacheSharedContext<?, ?> cctx, DataRegion dataRegion, DataRegionMetricsImpl regionMetrics, boolean readOnly ) { this.cctx = cctx; wal = cctx.wal(); this.dataRegion = dataRegion; this.regionMetrics = regionMetrics; this.readOnly = readOnly; log = cctx.logger(getClass()); this.failureProcessor = cctx.kernalContext().failure(); }
/** * Checks whether given cache configuration should be persisted. * * @param cacheCfg Cache config. * @return {@code True} if cache configuration should be persisted, {@code false} in other case. */ private boolean shouldPersist(CacheConfiguration<?, ?> cacheCfg) { return cctx.pageStore() != null && CU.isPersistentCache(cacheCfg, cctx.gridConfig().getDataStorageConfiguration()) && !cctx.kernalContext().clientNode(); }
/** * Force checkpoint. * * @param msg Message. * @return Checkpoint future or {@code null} if failed to get checkpointer. */ @Nullable private CheckpointFuture triggerCheckpoint(String msg) { return cctx.database().forceCheckpoint(msg); }
/** */ @Test public void test() throws Exception { IgniteEx ig = startGrid(0); ig.cluster().active(true); ig.context().cache().context().database().checkpointReadLock(); try { ig.context().cache().context().wal().log(new RolloverRecord()); } finally { ig.context().cache().context().database().checkpointReadUnlock(); } } }
/** {@inheritDoc} */ @Override public GridDhtPartitionTopology topology(DiscoCache discoCache) { return cctx.exchange().clientTopology(groupId(), discoCache); } }
/** {@inheritDoc} */ @Override public void beforeBinaryMemoryRestore(IgniteCacheDatabaseSharedManager mgr) throws IgniteCheckedException { cctx.pageStore().initializeForMetastorage(); }
/** {@inheritDoc} */ @Override protected CacheDataStore createCacheDataStore0(int p) throws IgniteCheckedException { if (ctx.database() instanceof GridCacheDatabaseSharedManager) ((GridCacheDatabaseSharedManager) ctx.database()).cancelOrWaitPartitionDestroy(grp.groupId(), p); boolean exists = ctx.pageStore() != null && ctx.pageStore().exists(grp.groupId(), p); return new GridCacheDataStore(p, exists); }
/** {@inheritDoc} */ @Nullable @Override public GridCacheContext singleCacheContext(GridCacheSharedContext cctx) { if (activeCacheIds.size() == 1) { int cacheId = activeCacheIds.get(0); return cctx.cacheContext(cacheId); } return null; }
/** * Invalidates page memory for given partition. Destroys partition store. * <b>NOTE:</b> This method can be invoked only within checkpoint lock or checkpointer thread. * * @param grpId Group ID. * @param partId Partition ID. * * @throws IgniteCheckedException If destroy has failed. */ public void destroyPartitionStore(int grpId, int partId) throws IgniteCheckedException { PageMemoryEx pageMemory = (PageMemoryEx)grp.dataRegion().pageMemory(); int tag = pageMemory.invalidate(grp.groupId(), partId); if (grp.walEnabled()) ctx.wal().log(new PartitionDestroyRecord(grp.groupId(), partId)); ctx.pageStore().onPartitionDestroyed(grpId, partId, tag); }
/** {@inheritDoc} */ @Override public CacheObject value() { if (val == null && valBytes != null) { GridCacheContext cacheCtx = cctx.cacheContext(cacheId); if (cacheCtx == null) throw new IgniteException("Failed to find cache context for the given cache ID: " + cacheId); IgniteCacheObjectProcessor co = cctx.kernalContext().cacheObjects(); val = co.toCacheObject(cacheCtx.cacheObjectContext(), valType, valBytes); } return val; }
/** * @throws StorageException If node is no longer valid and we missed a WAL operation. */ private void checkNode() throws StorageException { if (cctx.kernalContext().invalid()) throw new StorageException("Failed to perform WAL operation (environment was invalidated by a " + "previous error)"); }
/** * @param msg Message. * @return Cache or group descriptor. */ private Object descriptorForMessage(GridCacheMessage msg) { if (msg instanceof GridCacheIdMessage) return cctx.cache().cacheDescriptor(((GridCacheIdMessage)msg).cacheId()); else if (msg instanceof GridCacheGroupIdMessage) return cctx.cache().cacheGroupDescriptors().get(((GridCacheGroupIdMessage)msg).groupId()); return null; }
/** {@inheritDoc} */ @Override public void finishUnmarshal(GridCacheSharedContext ctx, ClassLoader ldr) throws IgniteCheckedException { super.finishUnmarshal(ctx, ldr); GridCacheContext cctx = ctx.cacheContext(cacheId); if (errBytes != null) err = U.unmarshal(ctx, errBytes, U.resolveClassLoader(ldr, ctx.gridConfig())); if (res != null) res.finishUnmarshal(cctx, ldr); }
/** * Returns cache object context if created or creates new and caches it until cache started. * * @param cacheId Cache id. */ @Nullable public CacheObjectContext cacheObjectContext(int cacheId) throws IgniteCheckedException { GridCacheContext<K, V> ctx = ctxMap.get(cacheId); if (ctx != null) return ctx.cacheObjectContext(); DynamicCacheDescriptor desc = cache().cacheDescriptor(cacheId); return desc != null ? desc.cacheObjectContext(kernalContext().cacheObjects()) : null; }
/** * @return Cache deployment manager. */ public GridCacheDeploymentManager<K, V> deploy() { return sharedCtx.deploy(); }