@Override public CompletableFuture<Object> invokeAsync() throws Throwable { GlobalComponentRegistry globalComponentRegistry = cacheManager.getGlobalComponentRegistry(); ComponentRegistry cacheComponentRegistry = globalComponentRegistry.getNamedComponentRegistry(cacheName); String name = cacheName.toString(); if (cacheComponentRegistry != null) { cacheComponentRegistry.getComponent(PersistenceManager.class).setClearOnStop(true); cacheComponentRegistry.getComponent(CacheJmxRegistration.class).setUnregisterCacheMBean(true); cacheComponentRegistry.getComponent(PassivationManager.class).skipPassivationOnStop(true); Cache<?, ?> cache = cacheManager.getCache(name, false); if (cache != null) { cache.stop(); } } globalComponentRegistry.removeCache(name); // Remove cache configuration and remove it from the computed cache name list globalComponentRegistry.getComponent(ConfigurationManager.class).removeConfiguration(name); // Remove cache from dependency graph //noinspection unchecked globalComponentRegistry .getComponent(DependencyGraph.class, CACHE_DEPENDENCY_GRAPH) .remove(cacheName); return CompletableFutures.completedNull(); }
private void unregisterProtobufMetadataManagerMBean(GlobalComponentRegistry gcr) { try { ObjectName objName = gcr.getComponent(ProtobufMetadataManager.class).getObjectName(); MBeanServer mBeanServer = JmxUtil.lookupMBeanServer(gcr.getGlobalConfiguration()); JmxUtil.unregisterMBean(objName, mBeanServer); } catch (Exception e) { throw new CacheException("Unable to unregister ProtobufMetadataManager MBean", e); } }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder c = getDefaultStandaloneCacheConfig(false); c.jmxStatistics().enable(); cacheManager = TestCacheManagerFactory.createCacheManager(c); memcachedServer = MemcachedTestingUtil.startMemcachedTextServer(cacheManager); port = memcachedServer.getPort(); memcachedClient = MemcachedTestingUtil.createMemcachedClient(60000, port); GlobalComponentRegistry gcr = TestingUtil.extractGlobalComponentRegistry(cacheManager); interpreter = gcr.getComponent(Interpreter.class); return cacheManager; }
@Override protected void setup() throws Exception { super.setup(); hotrodServer = HotRodClientTestingUtil.startHotRodServer(cacheManager); port = hotrodServer.getPort(); remoteCacheManager = new RemoteCacheManager( new org.infinispan.client.hotrod.configuration.ConfigurationBuilder() .addServers("localhost:" + hotrodServer.getPort()) .build()); remoteCacheManager.start(); GlobalComponentRegistry gcr = TestingUtil.extractGlobalComponentRegistry(cacheManager); interpreter = gcr.getComponent(Interpreter.class); }
/** * Replaces a component in a running cache manager (global component registry) * * @param cacheContainer cache in which to replace component * @param componentType component type of which to replace * @param replacementComponent new instance * @param rewire if true, ComponentRegistry.rewire() is called after replacing. * @return the original component that was replaced */ public static <T> T replaceComponent( CacheContainer cacheContainer, Class<T> componentType, T replacementComponent, boolean rewire) { GlobalComponentRegistry cr = extractGlobalComponentRegistry(cacheContainer); T old = cr.getComponent(componentType); cr.registerComponent(replacementComponent, componentType); if (rewire) { cr.rewire(); cr.rewireNamedRegistries(); } return old; }
protected static GMUVersionGenerator getGMUVersionGenerator( GlobalComponentRegistry globalComponentRegistry, String cacheName) { ComponentRegistry componentRegistry = globalComponentRegistry.getNamedComponentRegistry(cacheName); VersionGenerator versionGenerator = componentRegistry.getComponent(VersionGenerator.class); return toGMUVersionGenerator(versionGenerator); }
@Start(priority = 7) // Should start before global marshaller public void start() { loadInternalMarshallables(); loadForeignMarshallables(gcr.getGlobalConfiguration()); started = true; if (log.isTraceEnabled()) { log.tracef( "Constant object table was started and contains these externalizer readers: %s", readers); log.tracef("The externalizer writers collection contains: %s", writers); } }
@Override public Object perform(InvocationContext ctx) throws Throwable { // To avoid reliance of a thread local flag, get a reference for the // cache store to be able to clear it after cache has stopped. CacheStore store = cacheLoaderManager.getCacheStore(); cacheManager.getCache(cacheName).stop(); // After stopping the cache, clear it if (store != null) store.clear(); registry.removeCache(cacheName); return null; }
private SearchFactoryIntegrator getSearchFactory( Properties indexingProperties, ComponentRegistry cr) { Object component = cr.getComponent(SearchFactoryIntegrator.class); SearchFactoryIntegrator searchFactory = null; if (component instanceof SearchFactoryIntegrator) { // could be the placeholder Object REMOVED_REGISTRY_COMPONENT searchFactory = (SearchFactoryIntegrator) component; } // defend against multiple initialization: if (searchFactory == null) { GlobalComponentRegistry globalComponentRegistry = cr.getGlobalComponentRegistry(); EmbeddedCacheManager uninitializedCacheManager = globalComponentRegistry.getComponent(EmbeddedCacheManager.class); indexingProperties = addProgrammaticMappings(indexingProperties, cr); // Set up the search factory for Hibernate Search first. SearchConfiguration config = new SearchableCacheConfiguration( new Class[0], indexingProperties, uninitializedCacheManager, cr); searchFactory = new SearchFactoryBuilder().configuration(config).buildSearchFactory(); cr.registerComponent(searchFactory, SearchFactoryIntegrator.class); } return searchFactory; }
private void registerProtobufMetadataManagerMBean( ProtobufMetadataManager protobufMetadataManager, GlobalComponentRegistry gcr, String cacheManagerName) { GlobalConfiguration globalCfg = gcr.getGlobalConfiguration(); MBeanServer mBeanServer = JmxUtil.lookupMBeanServer(globalCfg); String groupName = "type=RemoteQuery,name=" + ObjectName.quote(cacheManagerName); String jmxDomain = JmxUtil.buildJmxDomain(globalCfg, mBeanServer, groupName); ComponentMetadataRepo metadataRepo = gcr.getComponentMetadataRepo(); ManageableComponentMetadata metadata = metadataRepo .findComponentMetadata(ProtobufMetadataManagerImpl.class) .toManageableComponentMetadata(); try { ResourceDMBean mBean = new ResourceDMBean(protobufMetadataManager, metadata); ObjectName objName = new ObjectName(jmxDomain + ":" + groupName + ",component=" + metadata.getJmxObjectName()); protobufMetadataManager.setObjectName(objName); JmxUtil.registerMBean(mBean, objName, mBeanServer); } catch (Exception e) { throw new CacheException("Unable to register ProtobufMetadataManager MBean", e); } }
@Override public Object readObject(Unmarshaller input) throws IOException, ClassNotFoundException { int readerIndex = input.readUnsignedByte(); int foreignId = -1; if (readerIndex == Ids.MAX_ID) { // User defined externalizer foreignId = UnsignedNumeric.readUnsignedInt(input); readerIndex = generateForeignReaderIndex(foreignId); } ExternalizerAdapter adapter = readers.get(readerIndex); if (adapter == null) { if (!started) { log.tracef( "Either the marshaller has stopped or hasn't started. Read externalizers are not properly populated: %s", readers); if (Thread.currentThread().isInterrupted()) { throw log.pushReadInterruptionDueToCacheManagerShutdown( readerIndex, new InterruptedException()); } else { throw log.cannotResolveExternalizerReader(gcr.getStatus(), readerIndex); } } else { if (log.isTraceEnabled()) { log.tracef("Unknown type. Input stream has %s to read", input.available()); log.tracef("Check contents of read externalizers: %s", readers); } if (foreignId > 0) throw log.missingForeignExternalizer(foreignId); throw log.unknownExternalizerReaderIndex(readerIndex); } } return adapter.readObject(input); }
@Override public void cacheManagerStarting(GlobalComponentRegistry gcr, GlobalConfiguration globalCfg) { metadataRepo = gcr.getComponentMetadataRepo(); }
@Override public void cacheManagerStarted(GlobalComponentRegistry gcr) { EmbeddedCacheManager cacheManager = gcr.getComponent(EmbeddedCacheManager.class); initProtobufMetadataManager((DefaultCacheManager) cacheManager, gcr); }
public static ExternalizerTable extractExtTable(CacheContainer cacheContainer) { GlobalComponentRegistry gcr = (GlobalComponentRegistry) extractField(cacheContainer, "globalComponentRegistry"); return gcr.getComponent(ExternalizerTable.class); }
public static AbstractDelegatingMarshaller extractGlobalMarshaller(EmbeddedCacheManager cm) { GlobalComponentRegistry gcr = (GlobalComponentRegistry) extractField(cm, "globalComponentRegistry"); return (AbstractDelegatingMarshaller) gcr.getComponent(StreamingMarshaller.class, KnownComponentNames.GLOBAL_MARSHALLER); }
/** Extracts a component of a given type from the cache's internal component registry */ public static <T> T extractGlobalComponent( CacheContainer cacheContainer, Class<T> componentType) { GlobalComponentRegistry gcr = extractGlobalComponentRegistry(cacheContainer); return gcr.getComponent(componentType); }
private void initProtobufMetadataManager( DefaultCacheManager cacheManager, GlobalComponentRegistry gcr) { ProtobufMetadataManagerImpl protobufMetadataManager = new ProtobufMetadataManagerImpl(); gcr.registerComponent(protobufMetadataManager, ProtobufMetadataManager.class); registerProtobufMetadataManagerMBean(protobufMetadataManager, gcr, cacheManager.getName()); }
private Map<Address, Object> executeOnClusterSync( final ReplicableCommand command, final int timeout, boolean totalOrder, boolean distributed) throws Exception { // first invoke remotely if (totalOrder) { Map<Address, Response> responseMap = transport.invokeRemotely( transport.getMembers(), command, ResponseMode.SYNCHRONOUS_IGNORE_LEAVERS, timeout, false, null, totalOrder, distributed); Map<Address, Object> responseValues = new HashMap<Address, Object>(transport.getMembers().size()); for (Map.Entry<Address, Response> entry : responseMap.entrySet()) { Address address = entry.getKey(); Response response = entry.getValue(); if (!response.isSuccessful()) { Throwable cause = response instanceof ExceptionResponse ? ((ExceptionResponse) response).getException() : null; throw new CacheException( "Unsuccessful response received from node " + address + ": " + response, cause); } responseValues.put(address, ((SuccessfulResponse) response).getResponseValue()); } return responseValues; } Future<Map<Address, Response>> remoteFuture = asyncTransportExecutor.submit( new Callable<Map<Address, Response>>() { @Override public Map<Address, Response> call() throws Exception { return transport.invokeRemotely( null, command, ResponseMode.SYNCHRONOUS_IGNORE_LEAVERS, timeout, true, null, false, false); } }); // invoke the command on the local node gcr.wireDependencies(command); Response localResponse; try { if (log.isTraceEnabled()) log.tracef("Attempting to execute command on self: %s", command); localResponse = (Response) command.perform(null); } catch (Throwable throwable) { throw new Exception(throwable); } if (!localResponse.isSuccessful()) { throw new CacheException("Unsuccessful local response: " + localResponse); } // wait for the remote commands to finish Map<Address, Response> responseMap = remoteFuture.get(timeout, TimeUnit.MILLISECONDS); // parse the responses Map<Address, Object> responseValues = new HashMap<Address, Object>(transport.getMembers().size()); for (Map.Entry<Address, Response> entry : responseMap.entrySet()) { Address address = entry.getKey(); Response response = entry.getValue(); if (!response.isSuccessful()) { Throwable cause = response instanceof ExceptionResponse ? ((ExceptionResponse) response).getException() : null; throw new CacheException( "Unsuccessful response received from node " + address + ": " + response, cause); } responseValues.put(address, ((SuccessfulResponse) response).getResponseValue()); } responseValues.put( transport.getAddress(), ((SuccessfulResponse) localResponse).getResponseValue()); return responseValues; }