@Override public void schedulerStarted() throws SchedulerException { clusterInfo.addClusterListener(this); Collection<ClusterNode> nodes = clusterInfo.getNodes();
/** * <p> * Called by the QuartzScheduler before the <code>JobStore</code> is used, in order to give the it a chance to * initialize. * </p> */ @Override // XXX: remove this suppression @SuppressWarnings("unchecked") public void initialize(ClassLoadHelper loadHelper, SchedulerSignaler schedulerSignaler) { this.terracottaClientId = clusterInfo.getCurrentNode().getId(); this.ftrCtr = System.currentTimeMillis(); // this MUST happen before initializing the trigger set (otherwise we might receive an update which get an NPE) // this.serializer.setClassLoadHelper(loadHelper); this.signaler = schedulerSignaler; getLog().info(getClass().getSimpleName() + " initialized."); ((ToolkitInternal) toolkit).registerBeforeShutdownHook(new ShutdownHook(this)); }
@Override public boolean isClusterOnline() { return cluster.areOperationsEnabled(); }
private void addInternal(ClusterTopologyListener listener) { cluster.addClusterListener(new ClusterListenerAdapter(listener, cluster)); }
@Override public Collection<ClusterNode> getNodes() { Collection<org.terracotta.toolkit.cluster.ClusterNode> toolkitNodes = cluster.getNodes(); Collection<ClusterNode> nodes = new ArrayList<ClusterNode>(); for (org.terracotta.toolkit.cluster.ClusterNode node : toolkitNodes) { nodes.add(new TerracottaNodeImpl(node)); } return nodes; }
private void removeInternal(ClusterTopologyListener listener) { cluster.removeClusterListener(new ClusterListenerAdapter(listener, cluster)); }
@Override public void start(ItemProcessor<E> itemProcessor, int processingConcurrency, ItemScatterPolicy<? super E> policy) { validateArgs(itemProcessor, processingConcurrency); nodeWriteLock.lock(); try { if (status == Status.STARTED) { LOGGER.warn("AsyncCoordinator " + name + " already started"); return; } if (status != Status.UNINITIALIZED) { throw new IllegalStateException(); } this.concurrency = processingConcurrency; this.scatterPolicy = getPolicy(policy, concurrency); this.processor = itemProcessor; cluster.addClusterListener(listener); startBuckets(concurrency); status = Status.STARTED; } finally { nodeWriteLock.unlock(); } processDeadNodes(); }
@Override public void stop() { nodeWriteLock.lock(); try { status.checkRunning(); status = Status.STOPPED; stopBuckets(localBuckets); stopBuckets(deadBuckets); cluster.removeClusterListener(listener); bucketManager.clear(); asyncFactoryCallback.callback(); lockHolder.release(toolkit.getLock(getAliveLockName(nodeName))); } finally { nodeWriteLock.unlock(); } }
/** * <p> * Called by the QuartzScheduler before the <code>JobStore</code> is used, in order to give the it a chance to * initialize. * </p> */ @Override // XXX: remove this suppression @SuppressWarnings("unchecked") public void initialize(ClassLoadHelper loadHelper, SchedulerSignaler schedulerSignaler) { this.terracottaClientId = clusterInfo.getCurrentNode().getId(); this.ftrCtr = System.currentTimeMillis(); // this MUST happen before initializing the trigger set (otherwise we might receive an update which get an NPE) // this.serializer.setClassLoadHelper(loadHelper); this.signaler = schedulerSignaler; getLog().info(getClass().getSimpleName() + " initialized."); ((ToolkitInternal) toolkit).registerBeforeShutdownHook(new ShutdownHook(this)); }
@Override public void schedulerStarted() throws SchedulerException { clusterInfo.addClusterListener(this); Collection<ClusterNode> nodes = clusterInfo.getNodes();
private boolean areOperationsEnabled() { return clusterInfo.areOperationsEnabled(); }
@Override public ClusterNode getCurrentNode() { return new TerracottaNodeImpl(cluster.getCurrentNode()); }
public void destroy() { try { debug("destroying bucket " + bucketName + " " + toolkitList.size()); toolkitList.destroy(); } catch (Throwable t) { if (isTCNRE(t) && !cluster.areOperationsEnabled()) { LOGGER .warn("destroyToolkitList caught TCNotRunningException on processing thread, but looks like we were shut down. " + "This can safely be ignored!", t); } } }
@Override public ClusterNode waitUntilNodeJoinsCluster() { return new TerracottaNodeImpl(cluster.getCurrentNode()); }
private void doProcessItems() throws ProcessingException { // process the quarantined items and remove them as they're processed // don't process work if this node's operations have been disabled if (!cluster.areOperationsEnabled()) { return; } else { if (config.isBatchingEnabled() && config.getBatchSize() > 0) { processBatchedItems(); } else { processListSnapshot(); } if (toolkitList.isEmpty() && stopState == STOP_STATE.STOP_REQUESTED) { signalStop(); } } }
@Override public void clusterOnline(ClusterNode node) { this.clusterOnline = true; this.currentNode = new TerracottaNodeImpl(toolkit.getClusterInfo().getCurrentNode()); }
private void nodeRejoined() { nodeWriteLock.lock(); try { currentNode = cluster.getCurrentNode(); nodeName = getAsyncNodeName(name, currentNode); debug("nodeRejoined currentNode " + currentNode + " nodeName " + nodeName); localBuckets.clear(); deadBuckets.clear(); lockHolder.reset(); startBuckets(concurrency); } finally { nodeWriteLock.unlock(); } processDeadNodes(); }
public AsyncCoordinatorImpl(String fullAsyncName, String cacheName, AsyncConfig config, ToolkitInstanceFactory toolkitInstanceFactory, Callback asyncFactoryCallback) { this.name = fullAsyncName; // contains CacheManager name and Cache name this.cacheName = cacheName; if (null == config) { this.config = DefaultAsyncConfig.getInstance(); } else { this.config = config; } this.toolkitInstanceFactory = toolkitInstanceFactory; this.toolkit = (ToolkitInternal) toolkitInstanceFactory.getToolkit(); this.aliveTimeoutSec = toolkit.getProperties().getLong(NODE_ALIVE_TIMEOUT_PROPERTY_NAME, 5L); this.cluster = toolkit.getClusterInfo(); this.listener = new AsyncClusterListener(); this.currentNode = cluster.getCurrentNode(); this.nodeName = getAsyncNodeName(name, currentNode); // contains CacheManager name, Cache name and nodeId this.localBuckets = new ArrayList<ProcessingBucket<E>>(); this.deadBuckets = new ArrayList<ProcessingBucket<E>>(); this.bucketManager = new BucketManager(); this.commonAsyncLock = toolkit.getLock(name); ReadWriteLock nodeLock = new ReentrantReadWriteLock(); this.nodeWriteLock = nodeLock.writeLock(); this.nodeReadLock = nodeLock.readLock(); this.asyncFactoryCallback = asyncFactoryCallback; this.lockHolder = new LockHolder(); }
@Override public void onClusterEvent(org.terracotta.toolkit.cluster.ClusterEvent event) { switch (event.getType()) { case NODE_JOINED: if (currentNode == null) { currentNode = new TerracottaNodeImpl(cluster.getCurrentNode()); } topologyListener.nodeJoined(new TerracottaNodeImpl(event.getNode())); break; case NODE_LEFT: topologyListener.nodeLeft(new TerracottaNodeImpl(event.getNode())); break; case OPERATIONS_DISABLED: topologyListener.clusterOffline(new TerracottaNodeImpl(event.getNode())); break; case OPERATIONS_ENABLED: topologyListener.clusterOnline(new TerracottaNodeImpl(event.getNode())); break; case NODE_REJOINED: TerracottaNodeImpl oldNode = currentNode; currentNode = new TerracottaNodeImpl(event.getNode()); topologyListener.clusterRejoined(oldNode, currentNode); break; case NODE_ERROR: // not bubbled upto ehcache layer yet break; } }