/** * @param cacheNames Survived caches to clean. */ public void removeSurvivedCaches(Set<String> cacheNames) { Iterator<T2<DynamicCacheDescriptor, NearCacheConfiguration>> it = locJoinStartCaches.iterator(); for (; it.hasNext();) { T2<DynamicCacheDescriptor, NearCacheConfiguration> entry = it.next(); DynamicCacheDescriptor desc = entry.get1(); if (cacheNames.contains(desc.cacheName())) it.remove(); } Iterator<DynamicCacheDescriptor> iter = locJoinInitCaches.iterator(); for (; iter.hasNext(); ) { DynamicCacheDescriptor desc = iter.next(); if (cacheNames.contains(desc.cacheName())) iter.remove(); } }
/** * @param node Node to check. * @return Public cache names accessible on the given node. */ public Map<String, CacheConfiguration> nodePublicCaches(ClusterNode node) { Map<String, CacheConfiguration> caches = U.newHashMap(registeredCaches.size()); for (DynamicCacheDescriptor cacheDesc : ctx.cache().cacheDescriptors().values()) { if (!cacheDesc.cacheType().userCache()) continue; CachePredicate p = registeredCaches.get(cacheDesc.cacheName()); if (p != null && p.cacheNode(node)) caches.put(cacheDesc.cacheName(), cacheDesc.cacheConfiguration()); } return caches; }
/** {@inheritDoc} */ @Override public Map<String, CacheConfiguration<?, ?>> startedCaches() { Map<Integer, DynamicCacheDescriptor> cachesMap = ctx.affinity().caches(); Map<String, CacheConfiguration<?, ?>> res = U.newHashMap(cachesMap.size()); for (DynamicCacheDescriptor desc : cachesMap.values()) { if (desc.cacheType().userCache()) res.put(desc.cacheName(), desc.cacheConfiguration()); } return res; }
/** * @param msg Message. * @param node Node sent message. */ public void onClientCacheChange(ClientCacheChangeDiscoveryMessage msg, ClusterNode node) { Map<Integer, Boolean> startedCaches = msg.startedCaches(); if (startedCaches != null) { for (Map.Entry<Integer, Boolean> e : startedCaches.entrySet()) { for (DynamicCacheDescriptor desc : registeredCaches.values()) { if (e.getKey().equals(desc.cacheId())) { ctx.discovery().addClientNode(desc.cacheName(), node.id(), e.getValue()); break; } } } } Set<Integer> closedCaches = msg.closedCaches(); if (closedCaches != null) { for (Integer cacheId : closedCaches) { for (DynamicCacheDescriptor desc : registeredCaches.values()) { if (cacheId.equals(desc.cacheId())) { ctx.discovery().onClientCacheClose(desc.cacheName(), node.id()); break; } } } } }
/** * Gets the cache for current cache id, ignoring any flags. * * @param ctx Kernal context. * @return Cache. */ protected IgniteCache rawCache(ClientConnectionContext ctx) { DynamicCacheDescriptor cacheDesc = cacheDescriptor(ctx); String cacheName = cacheDesc.cacheName(); return ctx.kernalContext().grid().cache(cacheName); }
/** {@inheritDoc} */ @Override public ClientResponse process(ClientConnectionContext ctx) { String cacheName = ClientCacheRequest.cacheDescriptor(ctx, cacheId).cacheName(); ctx.kernalContext().grid().destroyCache(cacheName); return super.process(ctx); } }
/** * Check security access for caches. * * @param cacheIds Cache IDs. */ private void checkSecurity(Collection<Integer> cacheIds) { if (F.isEmpty(cacheIds)) return; for (Integer cacheId : cacheIds) { DynamicCacheDescriptor desc = ctx.cache().cacheDescriptor(cacheId); if (desc != null) ctx.security().authorize(desc.cacheName(), SecurityPermission.CACHE_READ, null); } }
/** * @param ig Ignite. * @param cacheNames Cache names. */ protected void checkDescriptors(IgniteEx ig, Set<String> cacheNames) { Collection<DynamicCacheDescriptor> descs = ig.context().cache().cacheDescriptors().values(); assertEquals("Node name: " + ig.name(), cacheNames.size() + 1, descs.size()); int systemCnt = 0; for (DynamicCacheDescriptor desc : descs) if (!CU.isSystemCache(desc.cacheName())) assertTrue(desc.cacheName(), cacheNames.contains(desc.cacheName())); else systemCnt++; assertEquals(1, systemCnt); }
/** */ private Set<Integer> getGroupIds() { Set<Integer> grpIds = new HashSet<>(); if (arg.getCaches() != null && !arg.getCaches().isEmpty()) { Set<String> missingCaches = new HashSet<>(); for (String cacheName : arg.getCaches()) { DynamicCacheDescriptor desc = ignite.context().cache().cacheDescriptor(cacheName); if (desc == null || !isCacheMatchFilter(cacheName)) { missingCaches.add(cacheName); continue; } grpIds.add(desc.groupId()); } handlingMissedCaches(missingCaches); } else if (onlySpecificCaches()) { for (DynamicCacheDescriptor desc : ignite.context().cache().cacheDescriptors().values()) { if (desc.cacheConfiguration().getCacheMode() != LOCAL && isCacheMatchFilter(desc.cacheName())) grpIds.add(desc.groupId()); } } else grpIds = getCacheGroupIds(); return grpIds; }
.map(req -> req.descriptor().cacheName()) .collect(Collectors.toList());
log.error("Can't initialize query structures for not started cache [cacheName=" + cacheDesc.cacheName() + "]");
if (!compiled.matcher(desc.cacheName()).find()) continue; ci.setCacheName(desc.cacheName()); ci.setCacheId(desc.cacheId()); ci.setGrpName(desc.groupDescriptor().groupName()); ci.setMode(desc.cacheConfiguration().getCacheMode()); ci.setAtomicityMode(desc.cacheConfiguration().getAtomicityMode()); ci.setMapped(mapped(desc.cacheName()));
grpDesc.onCacheStopped(desc.cacheName(), desc.cacheId());
cacheId, desc.cacheName(), row.key(), o.toString(), row.key().valueBytes(grpCtx.cacheObjectContext()), row.version(), valHash));
String schema = QueryUtils.normalizeSchemaName(desc.cacheName(), desc.cacheConfiguration().getSqlSchema());
/** * Check that exception contains proper filename when trying to read corrupted cache configuration file. * * @throws Exception If failed. */ @Test public void testCorruptedCacheConfigurationsValidation() throws Exception { IgniteEx ig0 = (IgniteEx)startGrids(NODES); ig0.cluster().active(true); startCaches(ig0); DynamicCacheDescriptor desc = ig0.context().cache().cacheDescriptor(cacheName(2)); corruptCacheData(desc); stopAllGrids(); GridTestUtils.assertThrowsAnyCause(log, () -> startGrids(NODES), IgniteCheckedException.class, desc.cacheName() + CACHE_DATA_FILENAME); }