@Override public boolean isSatisfied() { try { return !memoryObjectStore.contains(TEST_GROUP_ID, "prefix.eventGroups"); } catch (ObjectStoreException e) { LOGGER.debug("Could not access object store."); return false; } }
/** * Removes all events from this group. * * @throws ObjectStoreException */ public void clear() throws ObjectStoreException { synchronized (this) { eventsObjectStore.clear(eventsPartitionKey); eventsObjectStore.disposePartition(eventsPartitionKey); } }
private void setAnswers() throws ObjectStoreException { doAnswer(invocation -> { countOfEventGroups++; eventGroupWasSaved = true; return null; }).when(partitionableObjectStore).store(any(), any(), any()); doAnswer(invocation -> { countOfEventGroups--; return null; }).when(partitionableObjectStore).remove(any(String.class), any(String.class)); } }
/** * Removes the elements in expiredAndDispatchedGroups when groupLife is reached */ @Override public void expired() { try { for (String o : (List<String>) correlatorStore.allKeys(getExpiredAndDispatchedPartitionKey())) { Long time = (Long) correlatorStore.retrieve(o, getExpiredAndDispatchedPartitionKey()); if (time + DAYS.toMillis(1) < currentTimeMillis()) { correlatorStore.remove(o, getExpiredAndDispatchedPartitionKey()); logger.warn(MessageFormat.format("Discarding group {0}", o)); } } } catch (ObjectStoreException e) { logger.warn("Expiration of objects failed due to ObjectStoreException " + e + "."); } }
private EventCorrelator createEventCorrelator() throws Exception { registerIntoMockContext(mockMuleContext, OBJECT_STORE_MANAGER, mockObjectStoreManager); memoryObjectStore.store(TEST_GROUP_ID, mockEventGroup, "prefix.eventGroups"); when(mockEventGroup.getGroupId()).thenReturn(TEST_GROUP_ID); when(mockEventGroup.getMessageCollectionEvent()).thenReturn(mock(CoreEvent.class)); when(mockFlowConstruct.getName()).thenReturn("flowName"); return new EventCorrelator(mockEventCorrelatorCallback, mockTimeoutMessageProcessor, mockMuleContext, mockFlowConstruct, memoryObjectStore, "prefix", mockProcessedGroups); }
private void setReturnsAndExceptions() throws Exception { when(muleContext.getConfiguration()).thenReturn(muleConfiguration); when(partitionableObjectStore.retrieve(any(String.class), any(String.class))) .thenThrow(ObjectDoesNotExistException.class); when(eventCorrelatorCallback.createEventGroup(any(CoreEvent.class), any(Object.class))).thenReturn(eventGroup); when(eventCorrelatorCallback.aggregateEvents(any(EventGroup.class))).thenThrow(RoutingException.class); when(eventCorrelatorCallback.shouldAggregateEvents(any(EventGroup.class))).thenReturn(true); }
/** * Returns a snapshot of collected events in this group, optionally sorted by their arrival time. * * @return an array of collected {@link CoreEvent}s. * @throws ObjectStoreException */ public PrivilegedEvent[] toArray(boolean sortByArrival) throws ObjectStoreException { synchronized (this) { if (eventsObjectStore.allKeys(eventsPartitionKey).isEmpty()) { return EMPTY_EVENTS_ARRAY; } List<String> keys = eventsObjectStore.allKeys(eventsPartitionKey); PrivilegedEvent[] eventArray = new PrivilegedEvent[keys.size()]; for (int i = 0; i < keys.size(); i++) { eventArray[i] = (PrivilegedEvent) eventsObjectStore.retrieve(keys.get(i), eventsPartitionKey); } if (sortByArrival) { Arrays.sort(eventArray, new ArrivalOrderEventComparator()); } return eventArray; } }
group.clear(); if (!correlatorStore.contains((String) group.getGroupId(), getExpiredAndDispatchedPartitionKey())) { newEvent); correlatorStore.store((String) group.getGroupId(), group.getCreated(), getExpiredAndDispatchedPartitionKey()); } else { logger.warn(MessageFormat.format("Discarding group {0}", group.getGroupId()));
@Test public void isDisposedEventGroupPartition() throws Exception { EventGroup eventGroup = new EventGroup(UUID.getUUID(), muleContext); PartitionableObjectStore objectStore = mock(PartitionableObjectStore.class); eventGroup.initEventsStore(objectStore); eventGroup.clear(); verify(objectStore).disposePartition(anyString()); }
@Override protected T doRemove(String key, String partitionName) throws ObjectStoreException { return wrapped.remove(key, partitionName); }
@Override public List<String> allKeys(String partitionName) throws ObjectStoreException { return wrapped.allKeys(partitionName); }
@Override public void close() throws ObjectStoreException { wrapped.close(); }
@Override public void clear(String partitionName) throws ObjectStoreException { wrapped.clear(partitionName); }
@Override public boolean isPersistent() { return wrapped.isPersistent(); } }
@Override public List<String> allPartitions() throws ObjectStoreException { return wrapped.allPartitions(); }
private void ensurePartitionIsCleared(boolean isPersistent) throws ObjectStoreException, InitialisationException { try { ObjectStorePartition<Serializable> store = createStorePartition(TEST_PARTITION_NAME, isPersistent); store.getBaseStore().store(TEST_KEY, TEST_VALUE, TEST_PARTITION_NAME); assertThat(store.allKeys().size(), is(1)); storeManager.disposeStore(TEST_PARTITION_NAME); assertThat(store.allKeys().size(), is(0)); } finally { storeManager.dispose(); } }
@Override protected T doRetrieve(String key, String partitionName) throws ObjectStoreException { return wrapped.retrieve(key, partitionName); }
int currentSize; currentSize = eventsObjectStore.allKeys(eventsPartitionKey).size(); Iterator<String> i = eventsObjectStore.allKeys(eventsPartitionKey).iterator(); while (i.hasNext()) { String id = i.next(); buf.append(eventsObjectStore.retrieve(id, eventsPartitionKey).getCorrelationId()); if (i.hasNext()) { buf.append(", ");
@Override public void disposePartition(String partitionName) throws ObjectStoreException { wrapped.disposePartition(partitionName); }
@Override protected T doRemove(String key) throws ObjectStoreException { return partitionedObjectStore.remove(key, partitionName); }