/** * 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); }
/** * @param enabled Enabled flag.. */ private void persistGlobalWalState(boolean enabled) { shared().database().walEnabled(grpId, enabled, false); }
/** * @param enabled Enabled flag.. */ private void persistLocalWalState(boolean enabled) { shared().database().walEnabled(grpId, enabled, true); }
/** * Evicts necessary number of data pages if per-page eviction is configured in current {@link DataRegion}. */ private void ensureFreeSpace() throws IgniteCheckedException { // Deadlock alert: evicting data page causes removing (and locking) all entries on the page one by one. assert !lock.isHeldByCurrentThread(); cctx.shared().database().ensureFreeSpace(cctx.dataRegion()); }
/** {@inheritDoc} */ @Override public void onBaselineChange() { onKernalStopCaches(true); stopCaches(true); sharedCtx.database().cleanupRestoredCaches(); }
/** Checkpoint read unlock. */ private void unlock() { ctx.cache().context().database().checkpointReadUnlock(); } }
/** * @param link Row link. * @param row New row data. * @return {@code True} if was able to update row. * @throws IgniteCheckedException If failed. */ public boolean updateRow(long link, CacheDataRow row, IoStatisticsHolder statHolder) throws IgniteCheckedException { assert !persistenceEnabled || ctx.database().checkpointLockIsHeldByThread(); if (rowCacheCleaner != null) rowCacheCleaner.remove(link); return freeList.updateDataRow(link, row, statHolder); }
/** {@inheritDoc} */ @Override public void invoke(GridCacheContext cctx, KeyCacheObject key, OffheapInvokeClosure c) throws IgniteCheckedException { assert ctx.database().checkpointLockIsHeldByThread(); CacheDataStore delegate = init0(false); delegate.invoke(cctx, key, c); }
/** {@inheritDoc} */ @Override public Collection<DataRegionMetrics> dataRegionMetrics() { guard(); try { return ctx.cache().context().database().memoryMetrics(); } finally { unguard(); } }
/** {@inheritDoc} */ @Override public void ensureStarted() throws IgniteCheckedException { if (!ctx.clientNode()) { assert mvccEnabled && mvccSupported; if (txLog == null) txLog = new TxLog(ctx, ctx.cache().context().database()); startVacuumWorkers(); if (log.isInfoEnabled()) log.info("Mvcc processor started."); } }
/** * Extract GridCacheDatabaseSharedManager. */ private GridCacheDatabaseSharedManager gridDatabase(Ignite ignite) { return (GridCacheDatabaseSharedManager)((IgniteEx)ignite).context().cache().context().database(); }
/** * @param ignite Ignite instance. */ private int getPageSize(IgniteEx ignite) { return ignite.context().cache().context().database().pageSize(); }
/** * @param context Context. */ private String extractDefaultPageMemoryAllocPath(GridKernalContext context) { IgniteCacheDatabaseSharedManager dbMgr = context.cache().context().database(); Map<String, DataRegion> memPlcMap = U.field(dbMgr, "dataRegionMap"); PageMemory pageMem = memPlcMap.get("default").pageMemory(); Object memProvider = U.field(pageMem, "directMemoryProvider"); Object memProvider0 = U.field(memProvider, "memProvider"); return ((File) U.field(memProvider0, "allocationPath")).getAbsolutePath(); }
/** * @param ig Ignite instance. */ private void triggerCheckpoint(IgniteEx ig) { GridCacheDatabaseSharedManager dbMgr = (GridCacheDatabaseSharedManager)ig.context() .cache().context().database(); dbMgr.wakeupForCheckpoint("test-should-fail"); }
/** {@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); }
/** * @param ig Ignite instance. * @return Memory and store. * @throws Exception If failed to initialize the store. */ private PageMemory getMemory(IgniteEx ig) throws Exception { final GridCacheSharedContext<Object, Object> sharedCtx = ig.context().cache().context(); final IgniteCacheDatabaseSharedManager db = sharedCtx.database(); return db.dataRegion(null).pageMemory(); } }
/** * Interrupts checkpoint thread for given node. * * @param node Node. */ private void interruptCheckpointer(IgniteEx node) { GridCacheDatabaseSharedManager dbMgr = (GridCacheDatabaseSharedManager) node.context().cache().context().database(); dbMgr.checkpointerThread().interrupt(); } }
/** * Verifies that expected memory policies are allocated when used doesn't provide any MemoryPolicyConfiguration. */ @Test public void testNoConfigProvided() throws Exception { memCfg = null; IgniteEx ignite = startGrid(0); Collection<DataRegion> allMemPlcs = ignite.context().cache().context().database().dataRegions(); assertEquals(3, allMemPlcs.size()); verifyDefaultAndSystemMemoryPolicies(allMemPlcs); }
/** */ private void verifyKeys(IgniteEx ig, byte keysCnt, String keyPrefix, String valPrefix ) throws IgniteCheckedException { MetaStorage metaStorage = ig.context().cache().context().database().metaStorage(); for (byte i = 0; i < keysCnt; i++) { Serializable val = metaStorage.read(keyPrefix + i); Assert.assertEquals(valPrefix + i, val); } }
/** * @param g Ignite instance. * @throws IgniteCheckedException If failed. */ private Collection<FullPageId> captureDirtyPages(IgniteEx g) throws IgniteCheckedException { GridCacheDatabaseSharedManager dbMgr = (GridCacheDatabaseSharedManager)g.context() .cache().context().database(); // Capture a set of dirty pages. PageMemoryImpl pageMem = (PageMemoryImpl)dbMgr.dataRegion("default").pageMemory(); return pageMem.dirtyPages(); }