protected void resetStatistics(Callable<Boolean> statsTask) { logger.trace("resetStatistics.enter; going to reset stats for schema: {}", schemaName); int cnt = 0; Map<Member, Future<Boolean>> futures = execService.submitToAllMembers(statsTask); for (Map.Entry<Member, Future<Boolean>> entry: futures.entrySet()) { try { if (entry.getValue().get()) { cnt++; } } catch (InterruptedException | ExecutionException ex) { logger.error("resetStatistics.error: " + ex.getMessage() + " on member " + entry.getKey(), ex); } } logger.trace("resetStatistics.exit; reset stats on {} nodes", cnt); }
public static void main(String[] args) throws Exception { HazelcastInstance hz = Hazelcast.newHazelcastInstance(); Map<String, Integer> map = hz.getMap("map"); for (int i = 0; i < 5; i++) { map.put(UUID.randomUUID().toString(), 1); } IExecutorService executor = hz.getExecutorService("executor"); Map<Member, Future<Integer>> result = executor.submitToAllMembers(new SumTask()); int sum = 0; for (Future<Integer> future : result.values()) { sum += future.get(); } System.out.println("Result: " + sum); } }
protected CompositeData getTotalsStatistics(Callable<CompositeData> statsTask, StatsAggregator aggregator) { logger.trace("getTotalsStatistics.enter; going to collect stats for schema: {}", schemaName); int cnt = 0; CompositeData result = null; Map<Member, Future<CompositeData>> futures = execService.submitToAllMembers(statsTask); for (Map.Entry<Member, Future<CompositeData>> entry: futures.entrySet()) { try { CompositeData stats = entry.getValue().get(); logger.trace("getTotalsStatistics; got stats: {}, from member {}", stats, entry.getKey()); result = JMXUtils.aggregateStats(stats, result, aggregator); logger.trace("getTotalsStatistics; got aggregated result: {}", result); cnt++; } catch (InterruptedException | ExecutionException ex) { logger.error("getTotalsStatistics.error: " + ex.getMessage(), ex); } } logger.trace("getTotalsStatistics.exit; got stats from {} nodes", cnt); return result; }
public TabularData getUsageStatistics(Callable<TabularData> statsTask, StatsAggregator aggregator) { logger.trace("getUsageStatistics.enter; going to collect stats for schema: {}", schemaName); int cnt = 0; TabularData result = null; Map<Member, Future<TabularData>> futures = execService.submitToAllMembers(statsTask); for (Map.Entry<Member, Future<TabularData>> entry: futures.entrySet()) { try { TabularData stats = entry.getValue().get(); logger.trace("getUsageStatistics; got stats: {}, from member {}", stats, entry.getKey()); result = JMXUtils.aggregateStats(stats, result, aggregator); logger.trace("getUsageStatistics; got aggregated result: {}", result); cnt++; } catch (InterruptedException | ExecutionException ex) { logger.error("getUsageStatistics.error: " + ex.getMessage(), ex); } } logger.trace("getUsageStatistics.exit; got stats from {} nodes", cnt); return result; }
protected TabularData getSeriesStatistics(Callable<TabularData> statsTask, StatsAggregator aggregator) { logger.trace("getSeriesStatistics.enter; going to collect stats for schema: {}", schemaName); int cnt = 0; TabularData result = null; Map<Member, Future<TabularData>> futures = execService.submitToAllMembers(statsTask); for (Map.Entry<Member, Future<TabularData>> entry: futures.entrySet()) { try { TabularData stats = entry.getValue().get(); logger.trace("getSeriesStatistics; got stats: {}, from member {}", stats, entry.getKey()); result = JMXUtils.aggregateStats(stats, result, aggregator); logger.trace("getSeriesStatistics; got aggregated result: {}", result); cnt++; } catch (InterruptedException | ExecutionException ex) { logger.error("getSeriesStatistics.error: " + ex.getMessage(), ex); } } logger.trace("getSeriesStatistics.exit; got stats from {} nodes", cnt); return result; }
private void setChildIdsPool(int poolSize) { if (poolSize > 0) { childIdsPool = new String[poolSize]; for (int i=0; i < poolSize; i++) { childIdsPool[i] = UUID.randomUUID().toString(); } ChildIdsRegistrator cir = new ChildIdsRegistrator(clientId, childIdsPool); hzClient.getExecutorService(PN_XDM_SCHEMA_POOL).submitToAllMembers(cir); // we don't need wait for response? } }
@ManagedOperation(description="clear Query cache") public boolean clearCache() { SchemaQueryCleaner task = new SchemaQueryCleaner(schemaName); Map<Member, Future<Boolean>> results = execService.submitToAllMembers(task); boolean result = true; for (Map.Entry<Member, Future<Boolean>> entry: results.entrySet()) { try { if (!entry.getValue().get()) { result = false; } } catch (InterruptedException | ExecutionException ex) { logger.error("clearCache.error; ", ex); } } return result; }
@ManagedOperation(description="Return number of not-stored-yet Documents") public int checkUpdatingDocuments() { DocumentQueueCounter task = new DocumentQueueCounter(); Map<Member, Future<Integer>> results = execService.submitToAllMembers(task); int result = 0; for (Map.Entry<Member, Future<Integer>> entry: results.entrySet()) { try { result += entry.getValue().get(); } catch (InterruptedException | ExecutionException ex) { logger.error("checkUpdatingDocuments.error; ", ex); //throw new RuntimeException(ex.getMessage()); } } return result; }
protected int denitSchemaInCluster(Schema schema) { logger.trace("denitSchemaInCluster.enter; schema: {}", schema); SchemaDenitiator denit = new SchemaDenitiator(schema.getName()); int cnt = 0; Map<Member, Future<Boolean>> result = execService.submitToAllMembers(denit); for (Map.Entry<Member, Future<Boolean>> entry: result.entrySet()) { try { Boolean ok = entry.getValue().get(); if (ok) cnt++; logger.debug("denitSchemaInCluster; Schema {}de-initialized on node {}", ok ? "" : "NOT ", entry.getKey()); } catch (InterruptedException | ExecutionException ex) { logger.error("denitSchemaInCluster.error; ", ex); } } int rcnt = result.size() - cnt; logger.info("denitSchemaInCluster.exit; schema {} de-initialized on {} nodes; returning: {}", schema, cnt, rcnt); return rcnt; }
private void executeOnMembers(String[] args) { // executeOnMembers <echo-string> try { IExecutorService executorService = hazelcast.getExecutorService("default"); Echo task = new Echo(args[1]); Map<Member, Future<String>> results = executorService.submitToAllMembers(task); for (Future f : results.values()) { println(f.get()); } } catch (InterruptedException e) { currentThread().interrupt(); e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } }
private void executeOnMembers(String[] args) { // executeOnMembers <echo-string> try { IExecutorService executorService = hazelcast.getExecutorService("default"); Echo task = new Echo(args[1]); Map<Member, Future<String>> results = executorService.submitToAllMembers(task); for (Future f : results.values()) { println(f.get()); } } catch (InterruptedException e) { currentThread().interrupt(); e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } }
private void executeOnMembers(String[] args) { // executeOnMembers <echo-string> try { IExecutorService executorService = hazelcast.getExecutorService("default"); Echo task = new Echo(args[1]); Map<Member, Future<String>> results = executorService.submitToAllMembers(task); for (Future f : results.values()) { println(f.get()); } } catch (InterruptedException e) { currentThread().interrupt(); e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } }
private void executeOnMembers(String[] args) { // executeOnMembers <echo-string> try { IExecutorService executorService = hazelcast.getExecutorService("default"); Echo task = new Echo(args[1]); Map<Member, Future<String>> results = executorService.submitToAllMembers(task); for (Future f : results.values()) { println(f.get()); } } catch (InterruptedException e) { currentThread().interrupt(); e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } }
@ManagedAttribute(description="Returns HealthManagement statistics, per node") public TabularData getHealthStatistics() { logger.trace("getHealthStatistics.enter;"); int cnt = 0; TabularData result = null; Callable<CompositeData> task = new SchemaHealthAggregator(); Map<Member, Future<CompositeData>> futures = execService.submitToAllMembers(task); for (Map.Entry<Member, Future<CompositeData>> entry: futures.entrySet()) { try { CompositeData counters = entry.getValue().get(); logger.trace("getHealthStatistics; got counters: {}, from member {}", counters, entry.getKey()); result = compositeToTabular("Health", "Desc", "Member", result, counters); logger.trace("getHealthStatistics; got aggregated result: {}", result); cnt++; } catch (InterruptedException | ExecutionException | OpenDataException ex) { logger.error("getHealthStatistics.error: " + ex.getMessage(), ex); } } logger.trace("getHealthStatistics.exit; got stats from {} nodes", cnt); return result; }
@ManagedOperation(description="Removes an existing Index") @ManagedOperationParameters({@ManagedOperationParameter(name = "name", description = "Index name to delete")}) public void dropIndex(String name) { logger.trace("dropIndex.enter;"); long stamp = System.currentTimeMillis(); if (!schemaManager.deleteIndex(name)) { throw new IllegalStateException("Index '" + name + "' in schema '" + schemaName + "' does not exist"); } IndexRemover task = new IndexRemover(name); Map<Member, Future<Boolean>> results = execService.submitToAllMembers(task); int cnt = 0; for (Map.Entry<Member, Future<Boolean>> entry: results.entrySet()) { try { if (entry.getValue().get()) { cnt++; } } catch (InterruptedException | ExecutionException ex) { logger.error("dropIndex.error; ", ex); } } stamp = System.currentTimeMillis() - stamp; logger.trace("dropIndex.exit; index deleted on {} members; time Taken: {}", cnt, stamp); }
@ManagedOperation(description="Removes an existing Trigger") @ManagedOperationParameters({@ManagedOperationParameter(name = "className", description = "Trigger className to delete")}) public void dropTrigger(String className) { logger.trace("dropTrigger.enter;"); long stamp = System.currentTimeMillis(); if (!schemaManager.deleteTrigger(className)) { throw new IllegalStateException("Trigger '" + className + "' in schema '" + schemaName + "' does not exist"); } TriggerRemover task = new TriggerRemover(className); Map<Member, Future<Boolean>> results = execService.submitToAllMembers(task); int cnt = 0; for (Map.Entry<Member, Future<Boolean>> entry: results.entrySet()) { try { if (entry.getValue().get()) { cnt++; } } catch (InterruptedException | ExecutionException ex) { logger.error("dropTrigger.error; ", ex); } } stamp = System.currentTimeMillis() - stamp; logger.trace("dropTrigger.exit; trigger deleted on {} members; timeTaken: {}", cnt, stamp); }
@ManagedOperation(description="delete all Schema documents") @ManagedOperationParameters({ @ManagedOperationParameter(name = "evictOnly", description = "Delete from Cache or from Cache and CacheStore too")}) public boolean clear(boolean evictOnly) { SchemaDocCleaner task = new SchemaDocCleaner(schemaName, evictOnly); Map<Member, Future<Boolean>> results = execService.submitToAllMembers(task); boolean result = true; for (Map.Entry<Member, Future<Boolean>> entry: results.entrySet()) { try { if (!entry.getValue().get()) { result = false; } } catch (InterruptedException | ExecutionException ex) { logger.error("clear.error; ", ex); //throw new RuntimeException(ex.getMessage()); } } return result; }
@ManagedOperation(description="Stops on-going schema population process") public void stopPopulation() { if (!this.schemaManager.isPersistent()) { // throw ex? return; } SchemaPopulator pop = new SchemaPopulator(schemaName, false, true); execService.submitToAllMembers(pop); } }
@ManagedOperation(description="Initiates schema population process") @ManagedOperationParameters({ @ManagedOperationParameter(name = "overrideExisting", description = "Override existing documents or not")}) public void startPopulation(boolean overrideExisting) { if (!this.schemaManager.isPersistent()) { // throw ex? return; } populators.clear(); SchemaPopulator pop = new SchemaPopulator(schemaName, overrideExisting, false); execService.submitToAllMembers(pop); }
public void checkPopulation(int currentSize) throws Exception { logger.info("checkPopulation; will start population at {} cluster size; current size is: {}", popClusterSize, currentSize); if (useCatalog) { activateDocStore(); xddCache.addEntryListener(this, true); } if (popClusterSize > 0 && popClusterSize == currentSize && getLoadedCount() == 0) { SchemaPopulator pop = new SchemaPopulator(schemaName, false, false); // we can't call it directly as it'll block current thread for a long time.. nodeEngine.getHazelcastInstance().getExecutorService(PN_XDM_SCHEMA_POOL).submitToAllMembers(pop); } }