@Override public List<String> getJobGroupNames() throws JobPersistenceException { return newArrayList(jobsByGroup.keySet()); }
@Override public List<String> getTriggerGroupNames() throws JobPersistenceException { return new LinkedList<>(triggersByGroup.keySet()); }
public Set<K> keySet() { if(guavaMultiMap != null) { synchronized (guavaMultiMap) { Set<K> c = guavaMultiMap.keySet(); if(c != null) return new HashSet<K>(c); else return null; } } return hcMultiMap.keySet(); }
@Override public Collection<String> keys() { return getMultiMap().keySet(); }
public static void main(String[] args) { HazelcastInstance hz = Hazelcast.newHazelcastInstance(); MultiMap<String, String> map = hz.getMultiMap("map"); for (String key : map.keySet()) { Collection<String> values = map.get(key); System.out.printf("%s -> %s\n", key, values); } } }
@Override public KeyIterator getKeys(final SliceQuery query, StoreTransaction txh) throws StorageException { final Iterator<byte[]> entries = Iterators.filter(cache.keySet().iterator(), new Predicate<byte[]>() { @Override public boolean apply(@Nullable byte[] rawKey) { Iterator<Column> columns = cache.get(rawKey).iterator(); Optional<Column> hit = Iterators.tryFind(columns, new Predicate<Column>() { @Override public boolean apply(Column input) { StaticBuffer c = new StaticArrayBuffer(input.name); return c.compareTo(query.getSliceStart()) >= 0 && c.compareTo(query.getSliceEnd()) < 0; } }); return hit.isPresent(); } }); return new HazelcatKeyIterator(entries, query); }
protected void handleMultiMapKeys() { Set set = getMultiMap().keySet(); Iterator it = set.iterator(); int count = 0; while (it.hasNext()) { count++; println(it.next()); } println("Total " + count); }
protected void handleMultiMapKeys() { Set set = getMultiMap().keySet(); Iterator it = set.iterator(); int count = 0; while (it.hasNext()) { count++; println(it.next()); } println("Total " + count); }
protected void handleMultiMapKeys() { Set set = getMultiMap().keySet(); Iterator it = set.iterator(); int count = 0; while (it.hasNext()) { count++; println(it.next()); } println("Total " + count); }
protected void handleMultiMapKeys() { Set set = getMultiMap().keySet(); Iterator it = set.iterator(); int count = 0; while (it.hasNext()) { count++; println(it.next()); } println("Total " + count); }
@Override public KeyIterator getKeys(final KeyRangeQuery query, StoreTransaction txh) throws StorageException { final Iterator<byte[]> entries = Iterators.filter(cache.keySet().iterator(), new Predicate<byte[]>() { @Override public boolean apply(@Nullable byte[] rawKey) { StaticBuffer key = new StaticArrayBuffer(rawKey); boolean acceptKey = key.compareTo(query.getKeyStart()) >= 0 && key.compareTo(query.getKeyEnd()) < 0; if (!acceptKey) return false; Iterator<Column> columns = cache.get(rawKey).iterator(); Optional<Column> hit = Iterators.tryFind(columns, new Predicate<Column>() { @Override public boolean apply(Column input) { StaticBuffer c = new StaticArrayBuffer(input.name); return c.compareTo(query.getSliceStart()) >= 0 && c.compareTo(query.getSliceEnd()) < 0; } }); return hit.isPresent(); } }); return new HazelcatKeyIterator(entries, query); }
private boolean isEventComingFromNonRegisteredHazelcastInstance( final HazelcastInstance hazelcastInstance, final Set<SocketAddress> localSocketAddressesSet, final InetSocketAddress socketAddressOfEvent) { final MultiMap<SocketAddress, SocketAddress> configMultiMap = hazelcastInstance .getMultiMap(HazelcastLocalInstanceRegistrar.SPRING_INTEGRATION_INTERNAL_CLUSTER_MULTIMAP); return configMultiMap.size() > 0 && !configMultiMap.values().contains(socketAddressOfEvent) && localSocketAddressesSet.contains(configMultiMap.keySet().iterator().next()); }
@Override public void pauseAll() throws JobPersistenceException { for (String triggerGroup : triggersByGroup.keySet()) { pauseTriggers(GroupMatcher.triggerGroupEquals(triggerGroup)); } }
it = getMap().keySet().iterator(); } else if (iteratorStr.startsWith("mm.")) { it = getMultiMap().keySet().iterator(); } else if (iteratorStr.startsWith("q.")) { it = getQueue().iterator();
private void syncConfigurationMultiMap(HazelcastInstance hazelcastInstance) { Lock lock = hazelcastInstance.getLock(SPRING_INTEGRATION_INTERNAL_CLUSTER_LOCK); lock.lock(); try { MultiMap<SocketAddress, SocketAddress> multiMap = hazelcastInstance .getMultiMap(SPRING_INTEGRATION_INTERNAL_CLUSTER_MULTIMAP); for (HazelcastInstance localInstance : Hazelcast.getAllHazelcastInstances()) { SocketAddress localInstanceSocketAddress = localInstance.getLocalEndpoint().getSocketAddress(); if (multiMap.size() == 0) { multiMap.put(localInstanceSocketAddress, localInstanceSocketAddress); } else { multiMap.put(multiMap.keySet().iterator().next(), localInstanceSocketAddress); } } } finally { lock.unlock(); } }
it = getMap().keySet().iterator(); } else if (iteratorStr.startsWith("mm.")) { it = getMultiMap().keySet().iterator(); } else if (iteratorStr.startsWith("q.")) { it = getQueue().iterator();
configMultiMap.remove(configMultiMap.keySet().iterator().next(), removedMemberSocketAddress);
@Override public Collection<String> pauseJobs(GroupMatcher<JobKey> groupMatcher) throws JobPersistenceException { List<String> pausedGroups = new LinkedList<>(); StringMatcher.StringOperatorName operator = groupMatcher .getCompareWithOperator(); switch (operator) { case EQUALS: if (pausedJobGroups.add(groupMatcher.getCompareToValue())) { pausedGroups.add(groupMatcher.getCompareToValue()); } break; default: for (String jobGroup : jobsByGroup.keySet()) { if (operator.evaluate(jobGroup, groupMatcher.getCompareToValue())) { if (pausedJobGroups.add(jobGroup)) { pausedGroups.add(jobGroup); } } } } for (String groupName : pausedGroups) { for (JobKey jobKey : getJobKeys(GroupMatcher.jobGroupEquals(groupName))) { pauseJob(jobKey); } } return pausedGroups; }
@Override public Collection<String> pauseTriggers(GroupMatcher<TriggerKey> matcher) throws JobPersistenceException { List<String> pausedGroups = new LinkedList<>(); StringMatcher.StringOperatorName operator = matcher.getCompareWithOperator(); switch (operator) { case EQUALS: if (pausedTriggerGroups.add(matcher.getCompareToValue())) { pausedGroups.add(matcher.getCompareToValue()); } break; default: for (String group : triggersByGroup.keySet()) { if (operator.evaluate(group, matcher.getCompareToValue())) { if (pausedTriggerGroups.add(matcher.getCompareToValue())) { pausedGroups.add(group); } } } } for (String pausedGroup : pausedGroups) { Set<TriggerKey> keys = getTriggerKeys(GroupMatcher.triggerGroupEquals(pausedGroup)); for (TriggerKey key : keys) { pauseTrigger(key); } } return pausedGroups; }
private static void verifyMultiMapForPayload( final MultiMap<Integer, HazelcastIntegrationTestUser> multiMap) { int index = 1; assertNotNull(multiMap); assertEquals(true, multiMap.size() == DATA_COUNT); SortedSet<Integer> keys = new TreeSet<>(multiMap.keySet()); for (Integer key : keys) { assertNotNull(key); assertEquals(index, key.intValue()); HazelcastIntegrationTestUser user = multiMap.get(key).iterator().next(); verifyHazelcastIntegrationTestUser(user, index); index++; } }